feat: add database-level error collection to relationship validation

Completed hierarchical error context by implementing database-level error collection that aggregates schema errors as an array.

Changes:
- Modified ValidateDatabaseSchemas to use MapRecordCollectErrors instead of ExtractTypeValidationErrors
- Database-level validation now collects errors from all schemas as an array
- Removed unused ExtractTypeValidationErrors import
- Added comprehensive tests in validateDatabaseSchemas.type.spec.ts covering:
  * Success case when all schemas are valid
  * Single invalid schema with full context chain (schema → table → relationship)
  * Multiple invalid schemas with errors collected as separate array items
  * Empty database success case

The complete error hierarchy is now:
- Database level: Array of schema errors
- Schema level: { schema, errors: [...table errors] }
- Table level: { table, errors: [...relationship errors] }
- Relationship level: { relationship, errors: [...validation errors] }

All validation errors maintain proper TypeValidationResult structure throughout the chain, enabling precise error reporting with full context at every level.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: oskardudycz

src/packages/dumbo/src/core/schema/components/relationships/relationshipValidation.ts

@@ -11,7 +11,6 @@ import type {
   AND,
   AnyTypeValidationError,
   AnyTypeValidationFailed,
-  ExtractTypeValidationErrors,
   FailOnFirstTypeValidationError,
   FilterNotExistingInUnion,
   HaveTuplesTheSameLength,
@@ -479,16 +478,20 @@ export type ValidateDatabaseSchema<
     ? ValidateSchemaTables<Tables, SchemaName, Schema, Schemas>
     : TypeValidationSuccess;
 
-export type ValidateDatabaseSchemas<Schemas extends DatabaseSchemas> = {
-  [SchemaName in keyof Schemas]: ValidateDatabaseSchema<
-    Schemas[SchemaName],
-    Schemas
-  >;
-}[keyof Schemas] extends infer Results
-  ? ExtractTypeValidationErrors<Results> extends never
-    ? TypeValidationSuccess
-    : TypeValidationError<ExtractTypeValidationErrors<Results>>
-  : TypeValidationSuccess;
+export type ValidateDatabaseSchemas<Schemas extends DatabaseSchemas> =
+  MapRecordCollectErrors<
+    Schemas,
+    {
+      [SchemaName in keyof Schemas]: ValidateDatabaseSchema<
+        Schemas[SchemaName],
+        Schemas
+      >;
+    }
+  > extends infer Results
+    ? AnyTypeValidationFailed<Results> extends true
+      ? TypeValidationError<Results>
+      : TypeValidationSuccess
+    : TypeValidationSuccess;
 
 // TODO: Use in DatabaseSchema schema component validation
 // export type ValidatedSchemaComponent<

src/packages/dumbo/src/core/schema/components/relationships/validateDatabaseSchemas.type.spec.ts

@@ -0,0 +1,216 @@
+import { describe, it } from 'node:test';
+import { SQL } from '../../../sql';
+import type { Equals, Expect, IsError } from '../../../testing';
+import type { TypeValidationResult } from '../../../typing';
+import { dumboSchema } from '../../dumboSchema';
+import { relationship } from './relationshipTypes';
+import type { ValidateDatabaseSchemas } from './relationshipValidation';
+
+const { schema, table, column } = dumboSchema;
+const { Integer, BigInteger } = SQL.column.type;
+
+void describe('ValidateDatabaseSchemas', () => {
+  const usersTable = table('users', {
+    columns: {
+      id: column('id', Integer),
+    },
+  });
+
+  const postsTable = table('posts', {
+    columns: {
+      post_id: column('post_id', Integer),
+      user_id: column('user_id', Integer),
+    },
+    relationships: {
+      user: relationship(['user_id'], ['public.users.id'], 'one-to-one'),
+    },
+  });
+
+  void it('returns success when all schemas are valid', () => {
+    const publicSchema = schema('public', {
+      users: usersTable,
+      posts: postsTable,
+    });
+
+    type ValidSchemas = {
+      public: typeof publicSchema;
+    };
+
+    type Result = ValidateDatabaseSchemas<ValidSchemas>;
+
+    type _Then = Expect<Equals<Result, TypeValidationResult<true, undefined>>>;
+  });
+
+  void it('collects errors from a single invalid schema', () => {
+    const invalidTable = table('invalid', {
+      columns: {
+        col1: column('col1', Integer),
+        col2: column('col2', Integer),
+      },
+      relationships: {
+        bad_rel: relationship(
+          ['col1', 'col2'],
+          ['public.users.id'],
+          'one-to-one',
+        ),
+      },
+    });
+
+    const publicSchema = schema('public', {
+      users: usersTable,
+      invalid: invalidTable,
+    });
+
+    type TestSchemas = {
+      public: typeof publicSchema;
+    };
+
+    type Result = ValidateDatabaseSchemas<TestSchemas>;
+
+    type Expected = TypeValidationResult<
+      false,
+      [
+        TypeValidationResult<
+          false,
+          {
+            schema: 'public';
+            errors: [
+              TypeValidationResult<
+                false,
+                {
+                  table: 'invalid';
+                  errors: [
+                    TypeValidationResult<
+                      false,
+                      {
+                        relationship: 'bad_rel';
+                        errors: [
+                          {
+                            errorCode: 'reference_length_mismatch';
+                            columns: readonly ['col1', 'col2'];
+                            references: readonly ['public.users.id'];
+                          },
+                        ];
+                      }
+                    >,
+                  ];
+                }
+              >,
+            ];
+          }
+        >,
+      ]
+    >;
+
+    type _Then = [Expect<IsError<Result>>, Expect<Equals<Result, Expected>>];
+  });
+
+  void it('collects errors from multiple invalid schemas', () => {
+    const invalidTable1 = table('invalid1', {
+      columns: {
+        col1: column('col1', Integer),
+      },
+      relationships: {
+        bad_rel: relationship(['col1'], ['nonexistent.table.id'], 'one-to-one'),
+      },
+    });
+
+    const schema1 = schema('schema1', {
+      invalid1: invalidTable1,
+    });
+
+    const invalidTable2 = table('invalid2', {
+      columns: {
+        col2: column('col2', BigInteger),
+      },
+      relationships: {
+        user: relationship(['col2'], ['schema1.invalid1.col1'], 'one-to-one'),
+      },
+    });
+
+    const schema2 = schema('schema2', {
+      invalid2: invalidTable2,
+    });
+
+    type TestSchemas = {
+      schema1: typeof schema1;
+      schema2: typeof schema2;
+    };
+
+    type Result = ValidateDatabaseSchemas<TestSchemas>;
+
+    type Expected = TypeValidationResult<
+      false,
+      [
+        TypeValidationResult<
+          false,
+          {
+            schema: 'schema1';
+            errors: [
+              TypeValidationResult<
+                false,
+                {
+                  table: 'invalid1';
+                  errors: [
+                    TypeValidationResult<
+                      false,
+                      {
+                        relationship: 'bad_rel';
+                        errors: [
+                          {
+                            errorCode: 'missing_schema';
+                            reference: 'nonexistent.table.id';
+                          },
+                        ];
+                      }
+                    >,
+                  ];
+                }
+              >,
+            ];
+          }
+        >,
+        TypeValidationResult<
+          false,
+          {
+            schema: 'schema2';
+            errors: [
+              TypeValidationResult<
+                false,
+                {
+                  table: 'invalid2';
+                  errors: [
+                    TypeValidationResult<
+                      false,
+                      {
+                        relationship: 'user';
+                        errors: [
+                          {
+                            errorCode: 'type_mismatch';
+                            reference: 'schema1.invalid1.col1';
+                            referenceType: 'INTEGER';
+                            columnTypeName: 'BIGINT';
+                          },
+                        ];
+                      }
+                    >,
+                  ];
+                }
+              >,
+            ];
+          }
+        >,
+      ]
+    >;
+
+    type _Then = [Expect<IsError<Result>>, Expect<Equals<Result, Expected>>];
+  });
+
+  void it('returns success when database has no schemas', () => {
+    type EmptySchemas = {};
+
+    type Result = ValidateDatabaseSchemas<EmptySchemas>;
+
+    type _Then = Expect<Equals<Result, TypeValidationResult<true, undefined>>>;
+  });
+});