Declarative database schema together with migrator unification v1

src/packages/dumbo/src/core/index.ts

@@ -6,6 +6,8 @@ import type {
   ExtractDumboDatabaseDriverOptions,
   InferDriverDatabaseType,
 } from './drivers';
+import { dumboSchema } from './schema';
+import { SQL, SQLColumnTypeTokensFactory } from './sql';
 
 export * from './connections';
 export * from './drivers';
@@ -15,6 +17,7 @@ export * from './query';
 export * from './schema';
 export * from './serializer';
 export * from './sql';
+export * from './testing';
 export * from './tracing';
 
 export type Dumbo<
@@ -39,3 +42,16 @@ export type DumboConnectionOptions<
         } & Omit<Options, 'driver' | 'driverType' | 'connectionString'>
       : never
     : never;
+
+declare module './sql' {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace SQL {
+    export const columnN: typeof dumboSchema.column & {
+      type: typeof SQLColumnTypeTokensFactory;
+    };
+  }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+(SQL as any).columnN = Object.assign(dumboSchema.column, {
+  type: SQLColumnTypeTokensFactory,
+});

src/packages/dumbo/src/core/schema/components/columnSchemaComponent.ts

@@ -0,0 +1,81 @@
+import type { AnyColumnTypeToken, SQLColumnToken } from '../../sql';
+import {
+  schemaComponent,
+  type SchemaComponent,
+  type SchemaComponentOptions,
+} from '../schemaComponent';
+
+export type ColumnURNType = 'sc:dumbo:column';
+export type ColumnURN<ColumnName extends string = string> =
+  `${ColumnURNType}:${ColumnName}`;
+
+export const ColumnURNType: ColumnURNType = 'sc:dumbo:column';
+export const ColumnURN = <ColumnName extends string = string>({
+  name,
+}: {
+  name: ColumnName;
+}): ColumnURN<ColumnName> => `${ColumnURNType}:${name}`;
+
+export type ColumnSchemaComponent<
+  ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string,
+  ColumnName extends string = string,
+> = SchemaComponent<
+  ColumnURN<ColumnName>,
+  Readonly<{
+    columnName: ColumnName;
+  }>
+> &
+  SQLColumnToken<ColumnType>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyColumnSchemaComponent = ColumnSchemaComponent<any>;
+
+export type ColumnSchemaComponentOptions<
+  ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string,
+> = Omit<SQLColumnToken<ColumnType>, 'name' | 'sqlTokenType'> &
+  SchemaComponentOptions;
+
+export const columnSchemaComponent = <
+  const ColumnType extends AnyColumnTypeToken | string =
+    | AnyColumnTypeToken
+    | string,
+  const TOptions extends
+    ColumnSchemaComponentOptions<ColumnType> = ColumnSchemaComponentOptions<ColumnType>,
+  const ColumnName extends string = string,
+>(
+  params: {
+    columnName: ColumnName;
+  } & TOptions,
+): ColumnSchemaComponent<ColumnType, ColumnName> &
+  (TOptions extends { notNull: true } | { primaryKey: true }
+    ? { notNull: true }
+    : { notNull?: false }) => {
+  const {
+    columnName,
+    type,
+    notNull,
+    unique,
+    primaryKey,
+    default: defaultValue,
+    ...schemaOptions
+  } = params;
+
+  const sc = schemaComponent(ColumnURN({ name: columnName }), schemaOptions);
+
+  const result: Record<string, unknown> = {
+    ...sc,
+    columnName,
+    notNull,
+    unique,
+    primaryKey,
+    defaultValue,
+    sqlTokenType: 'SQL_COLUMN',
+    name: columnName,
+    type,
+  };
+
+  return result as ColumnSchemaComponent<ColumnType, ColumnName> &
+    (TOptions extends { notNull: true } | { primaryKey: true }
+      ? { notNull: true }
+      : { notNull?: false });
+};

src/packages/dumbo/src/core/schema/components/databaseSchemaComponent.ts

@@ -0,0 +1,83 @@
+import {
+  mapSchemaComponentsOfType,
+  schemaComponent,
+  type SchemaComponent,
+  type SchemaComponentOptions,
+} from '../schemaComponent';
+import {
+  DatabaseSchemaURNType,
+  databaseSchemaSchemaComponent,
+  type AnyDatabaseSchemaSchemaComponent,
+  type DatabaseSchemaSchemaComponent,
+} from './databaseSchemaSchemaComponent';
+
+export type DatabaseURNType = 'sc:dumbo:database';
+export type DatabaseURN = `${DatabaseURNType}:${string}`;
+
+export const DatabaseURNType: DatabaseURNType = 'sc:dumbo:database';
+export const DatabaseURN = ({ name }: { name: string }): DatabaseURN =>
+  `${DatabaseURNType}:${name}`;
+
+export type DatabaseSchemas<
+  Schemas extends
+    AnyDatabaseSchemaSchemaComponent = AnyDatabaseSchemaSchemaComponent,
+> = Record<string, Schemas>;
+
+export type DatabaseSchemaComponent<
+  Schemas extends DatabaseSchemas = DatabaseSchemas,
+> = SchemaComponent<
+  DatabaseURN,
+  Readonly<{
+    databaseName: string;
+    schemas: ReadonlyMap<string, DatabaseSchemaSchemaComponent> & Schemas;
+    addSchema: (
+      schema: string | DatabaseSchemaSchemaComponent,
+    ) => DatabaseSchemaSchemaComponent;
+  }>
+>;
+
+export type AnyDatabaseSchemaComponent =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  DatabaseSchemaComponent<any>;
+
+export const databaseSchemaComponent = <
+  Schemas extends DatabaseSchemas = DatabaseSchemas,
+>({
+  databaseName,
+  schemas,
+  ...migrationsOrComponents
+}: {
+  databaseName: string;
+  schemas?: Schemas;
+} & SchemaComponentOptions): DatabaseSchemaComponent<Schemas> => {
+  schemas ??= {} as Schemas;
+
+  const base = schemaComponent(DatabaseURN({ name: databaseName }), {
+    migrations: migrationsOrComponents.migrations ?? [],
+    components: [
+      ...(migrationsOrComponents.components ?? []),
+      ...Object.values(schemas),
+    ],
+  });
+
+  return {
+    ...base,
+    databaseName,
+    get schemas() {
+      const schemasMap =
+        mapSchemaComponentsOfType<DatabaseSchemaSchemaComponent>(
+          base.components,
+          DatabaseSchemaURNType,
+          (c) => c.schemaName,
+        );
+
+      return Object.assign(schemasMap, schemas);
+    },
+    addSchema: (schema: string | DatabaseSchemaSchemaComponent) =>
+      base.addComponent(
+        typeof schema === 'string'
+          ? databaseSchemaSchemaComponent({ schemaName: schema })
+          : schema,
+      ),
+  };
+};

src/packages/dumbo/src/core/schema/components/databaseSchemaSchemaComponent.ts

@@ -0,0 +1,87 @@
+import {
+  mapSchemaComponentsOfType,
+  schemaComponent,
+  type SchemaComponent,
+  type SchemaComponentOptions,
+} from '../schemaComponent';
+import {
+  TableURNType,
+  tableSchemaComponent,
+  type AnyTableSchemaComponent,
+  type TableSchemaComponent,
+} from './tableSchemaComponent';
+
+export type DatabaseSchemaURNType = 'sc:dumbo:database_schema';
+export type DatabaseSchemaURN<SchemaName extends string = string> =
+  `${DatabaseSchemaURNType}:${SchemaName}`;
+
+export const DatabaseSchemaURNType: DatabaseSchemaURNType =
+  'sc:dumbo:database_schema';
+export const DatabaseSchemaURN = <SchemaName extends string = string>({
+  name,
+}: {
+  name: SchemaName;
+}): DatabaseSchemaURN<SchemaName> => `${DatabaseSchemaURNType}:${name}`;
+
+export type DatabaseSchemaTables<
+  Tables extends AnyTableSchemaComponent = AnyTableSchemaComponent,
+> = Record<string, Tables>;
+
+export type DatabaseSchemaSchemaComponent<
+  Tables extends DatabaseSchemaTables = DatabaseSchemaTables,
+  SchemaName extends string = string,
+> = SchemaComponent<
+  DatabaseSchemaURN<SchemaName>,
+  Readonly<{
+    schemaName: SchemaName;
+    tables: ReadonlyMap<string, TableSchemaComponent> & Tables;
+    addTable: (table: string | TableSchemaComponent) => TableSchemaComponent;
+  }>
+>;
+
+export type AnyDatabaseSchemaSchemaComponent =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  DatabaseSchemaSchemaComponent<any, any>;
+
+export const databaseSchemaSchemaComponent = <
+  const Tables extends DatabaseSchemaTables = DatabaseSchemaTables,
+  const SchemaName extends string = string,
+>({
+  schemaName,
+  tables,
+  ...migrationsOrComponents
+}: {
+  schemaName: SchemaName;
+  tables?: Tables;
+} & SchemaComponentOptions): DatabaseSchemaSchemaComponent<
+  Tables,
+  SchemaName
+> => {
+  const base = schemaComponent(DatabaseSchemaURN({ name: schemaName }), {
+    migrations: migrationsOrComponents.migrations ?? [],
+    components: [
+      ...(migrationsOrComponents.components ?? []),
+      ...Object.values(tables ?? {}),
+    ],
+  });
+
+  return {
+    ...base,
+    schemaName,
+    get tables() {
+      const tablesMap = mapSchemaComponentsOfType<TableSchemaComponent>(
+        base.components,
+        TableURNType,
+        (c) => c.tableName,
+      );
+
+      return Object.assign(tablesMap, tables);
+    },
+    addTable: (table: string | TableSchemaComponent) =>
+      base.addComponent(
+        typeof table === 'string'
+          ? tableSchemaComponent({ tableName: table })
+          : table,
+      ),
+  };
+};

src/packages/dumbo/src/core/schema/components/index.ts

@@ -0,0 +1,25 @@
+import { ColumnURN } from './columnSchemaComponent';
+import { DatabaseURN } from './databaseSchemaComponent';
+import { DatabaseSchemaURN } from './databaseSchemaSchemaComponent';
+import { IndexURN } from './indexSchemaComponent';
+import { TableURN } from './tableSchemaComponent';
+
+export * from './columnSchemaComponent';
+export * from './databaseSchemaComponent';
+export * from './databaseSchemaSchemaComponent';
+export * from './indexSchemaComponent';
+export * from './relationships';
+export * from './tableSchemaComponent';
+export * from './tableTypesInference';
+
+export const schemaComponentURN = {
+  database: DatabaseURN,
+  schema: DatabaseSchemaURN,
+  table: TableURN,
+  column: ColumnURN,
+  index: IndexURN,
+  extractName: (urn: string): string => {
+    const parts = urn.split(':');
+    return parts[parts.length - 1] || '';
+  },
+} as const;

src/packages/dumbo/src/core/schema/components/indexSchemaComponent.ts

@@ -0,0 +1,50 @@
+import {
+  schemaComponent,
+  type SchemaComponent,
+  type SchemaComponentOptions,
+} from '../schemaComponent';
+import { type ColumnSchemaComponent } from './columnSchemaComponent';
+
+export type IndexURNType = 'sc:dumbo:index';
+export type IndexURN = `${IndexURNType}:${string}`;
+
+export type IndexSchemaComponent = SchemaComponent<
+  IndexURN,
+  Readonly<{
+    indexName: string;
+    columnNames: ReadonlyArray<string>;
+    isUnique: boolean;
+    addColumn: (column: string | ColumnSchemaComponent) => void;
+  }>
+>;
+
+export const IndexURNType: IndexURNType = 'sc:dumbo:index';
+export const IndexURN = ({ name }: { name: string }): IndexURN =>
+  `${IndexURNType}:${name}`;
+
+export const indexSchemaComponent = ({
+  indexName,
+  columnNames,
+  isUnique,
+  ...migrationsOrComponents
+}: {
+  indexName: string;
+  columnNames: string[];
+  isUnique: boolean;
+} & SchemaComponentOptions): IndexSchemaComponent => {
+  const sc = schemaComponent(IndexURN({ name: indexName }), {
+    migrations: migrationsOrComponents.migrations ?? [],
+    components: [...(migrationsOrComponents.components ?? [])],
+  });
+
+  return {
+    ...sc,
+    indexName,
+    get columnNames() {
+      return columnNames;
+    },
+    addColumn: (column: string | ColumnSchemaComponent) =>
+      columnNames.push(typeof column === 'string' ? column : column.columnName),
+    isUnique,
+  };
+};