metal-orm 1.0.14 → 1.0.15

package/src/core/ddl/introspect/catalogs/index.ts

@@ -0,0 +1 @@
+export * from './postgres.js';

package/src/core/ddl/introspect/catalogs/postgres.ts

@@ -0,0 +1,143 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column.js';
+
+export const PgInformationSchemaColumns = defineTable(
+  'columns',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    data_type: col.varchar(255),
+    is_nullable: col.varchar(3),
+    column_default: col.varchar(1024),
+    ordinal_position: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgClass = defineTable(
+  'pg_class',
+  {
+    oid: col.int(),
+    relname: col.varchar(255),
+    relnamespace: col.int(),
+    relkind: col.varchar(1)
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgNamespace = defineTable(
+  'pg_namespace',
+  {
+    oid: col.int(),
+    nspname: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgIndex = defineTable(
+  'pg_index',
+  {
+    indrelid: col.int(),
+    indexrelid: col.int(),
+    indisprimary: col.boolean(),
+    indkey: col.varchar(255),
+    indpred: col.varchar(1024)
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgAttribute = defineTable(
+  'pg_attribute',
+  {
+    attrelid: col.int(),
+    attname: col.varchar(255),
+    attnum: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgTableConstraints = defineTable(
+  'table_constraints',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_catalog: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    constraint_type: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgKeyColumnUsage = defineTable(
+  'key_column_usage',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_catalog: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    ordinal_position: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgConstraintColumnUsage = defineTable(
+  'constraint_column_usage',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_catalog: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgReferentialConstraints = defineTable(
+  'referential_constraints',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    unique_constraint_catalog: col.varchar(255),
+    unique_constraint_schema: col.varchar(255),
+    unique_constraint_name: col.varchar(255),
+    match_option: col.varchar(64),
+    update_rule: col.varchar(64),
+    delete_rule: col.varchar(64)
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export default {
+  PgInformationSchemaColumns,
+  PgClass,
+  PgNamespace,
+  PgIndex,
+  PgAttribute
+};

package/src/core/ddl/introspect/context.ts

@@ -0,0 +1,9 @@
+import type { Dialect } from '../../dialect/abstract.js';
+import type { DbExecutor } from '../../execution/db-executor.js';
+
+export interface IntrospectContext {
+  dialect: Dialect;
+  executor: DbExecutor;
+}
+
+export default IntrospectContext;

package/src/core/ddl/introspect/functions/postgres.ts

@@ -0,0 +1,26 @@
+// Small helpers to build Postgres-specific function calls as AST FunctionNodes
+import { columnOperand, valueToOperand } from '../../../ast/expression-builders.js';
+import type { OperandNode, FunctionNode } from '../../../ast/expression.js';
+
+type OperandInput = OperandNode | string | number | boolean | null;
+
+const toOperand = (v: OperandInput) => {
+  if (v === null) return valueToOperand(null);
+  if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') return valueToOperand(v);
+  return v as OperandNode;
+};
+
+const fn = (name: string, args: OperandInput[]): FunctionNode => ({
+  type: 'Function',
+  name,
+  fn: name,
+  args: args.map(toOperand)
+});
+
+export const pgGetExpr = (expr: OperandInput, relid: OperandInput): FunctionNode =>
+  fn('pg_get_expr', [expr, relid]);
+
+export const formatType = (typeOid: OperandInput, typmod: OperandInput): FunctionNode =>
+  fn('format_type', [typeOid, typmod]);
+
+export default { pgGetExpr, formatType };

package/src/core/ddl/introspect/mssql.ts

@@ -1,149 +1,149 @@
-import { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { queryRows, shouldIncludeTable } from './utils.js';
-import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
-import { DbExecutor } from '../../orm/db-executor.js';
-
-export const mssqlIntrospector: SchemaIntrospector = {
-  async introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema> {
-    const schema = options.schema;
-    const filterSchema = schema ? 'sch.name = @p1' : '1=1';
-    const params = schema ? [schema] : [];
-
-    const columnRows = await queryRows(
-      executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        c.name AS column_name,
-        ty.name AS data_type,
-        c.is_nullable,
-        c.is_identity,
-        object_definition(c.default_object_id) AS column_default
-      FROM sys.columns c
-      JOIN sys.tables t ON t.object_id = c.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      JOIN sys.types ty ON ty.user_type_id = c.user_type_id
-      WHERE t.is_ms_shipped = 0 AND ${filterSchema}
-      `,
-      params
-    );
-
-    const pkRows = await queryRows(
-      executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        c.name AS column_name,
-        ic.key_ordinal
-      FROM sys.indexes i
-      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
-      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
-      JOIN sys.tables t ON t.object_id = i.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      WHERE i.is_primary_key = 1 AND ${filterSchema}
-      ORDER BY ic.key_ordinal
-      `,
-      params
-    );
-
-    const pkMap = new Map<string, string[]>();
-    pkRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      const list = pkMap.get(key) || [];
-      list.push(r.column_name);
-      pkMap.set(key, list);
-    });
-
-    const indexRows = await queryRows(
-      executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        i.name AS index_name,
-        i.is_unique,
-        i.has_filter,
-        i.filter_definition
-      FROM sys.indexes i
-      JOIN sys.tables t ON t.object_id = i.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      WHERE i.is_primary_key = 0 AND i.is_hypothetical = 0 AND ${filterSchema}
-      `,
-      params
-    );
-
-    const indexColsRows = await queryRows(
-      executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        i.name AS index_name,
-        c.name AS column_name,
-        ic.key_ordinal
-      FROM sys.index_columns ic
-      JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
-      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
-      JOIN sys.tables t ON t.object_id = i.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      WHERE i.is_primary_key = 0 AND ${filterSchema}
-      ORDER BY ic.key_ordinal
-      `,
-      params
-    );
-
-    const indexColumnsMap = new Map<string, { column: string; order: number }[]>();
-    indexColsRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
-      const list = indexColumnsMap.get(key) || [];
-      list.push({ column: r.column_name, order: r.key_ordinal });
-      indexColumnsMap.set(key, list);
-    });
-
-    const tablesByKey = new Map<string, DatabaseTable>();
-
-    columnRows.forEach(r => {
-      if (!shouldIncludeTable(r.table_name, options)) return;
-      const key = `${r.table_schema}.${r.table_name}`;
-      if (!tablesByKey.has(key)) {
-        tablesByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
-          columns: [],
-          primaryKey: pkMap.get(key) || [],
-          indexes: []
-        });
-      }
-      const t = tablesByKey.get(key)!;
-      const column: DatabaseColumn = {
-        name: r.column_name,
-        type: r.data_type,
-        notNull: r.is_nullable === false || r.is_nullable === 0,
-        default: r.column_default ?? undefined,
-        autoIncrement: !!r.is_identity
-      };
-      t.columns.push(column);
-    });
-
-    indexRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      const table = tablesByKey.get(key);
-      if (!table) return;
-      const cols = (indexColumnsMap.get(`${r.table_schema}.${r.table_name}.${r.index_name}`) || [])
-        .sort((a, b) => a.order - b.order)
-        .map(c => ({ column: c.column }));
-      const idx: DatabaseIndex = {
-        name: r.index_name,
-        columns: cols,
-        unique: !!r.is_unique,
-        where: r.has_filter ? r.filter_definition : undefined
-      };
-      table.indexes = table.indexes || [];
-      table.indexes.push(idx);
-    });
-
-    return { tables: Array.from(tablesByKey.values()) };
-  }
-};
+import { SchemaIntrospector, IntrospectOptions } from './types.js';
+import { queryRows, shouldIncludeTable } from './utils.js';
+import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
+import { DbExecutor } from '../../execution/db-executor.js';
+
+export const mssqlIntrospector: SchemaIntrospector = {
+  async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const schema = options.schema;
+    const filterSchema = schema ? 'sch.name = @p1' : '1=1';
+    const params = schema ? [schema] : [];
+
+    const columnRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ty.name AS data_type,
+        c.is_nullable,
+        c.is_identity,
+        object_definition(c.default_object_id) AS column_default
+      FROM sys.columns c
+      JOIN sys.tables t ON t.object_id = c.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      JOIN sys.types ty ON ty.user_type_id = c.user_type_id
+      WHERE t.is_ms_shipped = 0 AND ${filterSchema}
+      `,
+      params
+    );
+
+    const pkRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ic.key_ordinal
+      FROM sys.indexes i
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 1 AND ${filterSchema}
+      ORDER BY ic.key_ordinal
+      `,
+      params
+    );
+
+    const pkMap = new Map<string, string[]>();
+    pkRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+
+    const indexRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        i.name AS index_name,
+        i.is_unique,
+        i.has_filter,
+        i.filter_definition
+      FROM sys.indexes i
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 0 AND i.is_hypothetical = 0 AND ${filterSchema}
+      `,
+      params
+    );
+
+    const indexColsRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        i.name AS index_name,
+        c.name AS column_name,
+        ic.key_ordinal
+      FROM sys.index_columns ic
+      JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 0 AND ${filterSchema}
+      ORDER BY ic.key_ordinal
+      `,
+      params
+    );
+
+    const indexColumnsMap = new Map<string, { column: string; order: number }[]>();
+    indexColsRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
+      const list = indexColumnsMap.get(key) || [];
+      list.push({ column: r.column_name, order: r.key_ordinal });
+      indexColumnsMap.set(key, list);
+    });
+
+    const tablesByKey = new Map<string, DatabaseTable>();
+
+    columnRows.forEach(r => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const t = tablesByKey.get(key)!;
+      const column: DatabaseColumn = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === false || r.is_nullable === 0,
+        default: r.column_default ?? undefined,
+        autoIncrement: !!r.is_identity
+      };
+      t.columns.push(column);
+    });
+
+    indexRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (indexColumnsMap.get(`${r.table_schema}.${r.table_name}.${r.index_name}`) || [])
+        .sort((a, b) => a.order - b.order)
+        .map(c => ({ column: c.column }));
+      const idx: DatabaseIndex = {
+        name: r.index_name,
+        columns: cols,
+        unique: !!r.is_unique,
+        where: r.has_filter ? r.filter_definition : undefined
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};

package/src/core/ddl/introspect/mysql.ts

@@ -1,99 +1,99 @@
-import { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { queryRows, shouldIncludeTable } from './utils.js';
-import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
-import { DbExecutor } from '../../orm/db-executor.js';
-
-export const mysqlIntrospector: SchemaIntrospector = {
-  async introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema> {
-    const schema = options.schema;
-    const filterClause = schema ? 'table_schema = ?' : 'table_schema = database()';
-    const params = schema ? [schema] : [];
-
-    const columnRows = await queryRows(
-      executor,
-      `
-      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default, extra
-      FROM information_schema.columns
-      WHERE ${filterClause}
-      ORDER BY table_name, ordinal_position
-      `,
-      params
-    );
-
-    const pkRows = await queryRows(
-      executor,
-      `
-      SELECT table_schema, table_name, column_name
-      FROM information_schema.key_column_usage
-      WHERE constraint_name = 'PRIMARY' AND ${filterClause}
-      ORDER BY ordinal_position
-      `,
-      params
-    );
-
-    const pkMap = new Map<string, string[]>();
-    pkRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      const list = pkMap.get(key) || [];
-      list.push(r.column_name);
-      pkMap.set(key, list);
-    });
-
-    const indexRows = await queryRows(
-      executor,
-      `
-      SELECT
-        table_schema,
-        table_name,
-        index_name,
-        non_unique,
-        GROUP_CONCAT(column_name ORDER BY seq_in_index) AS cols
-      FROM information_schema.statistics
-      WHERE ${filterClause} AND index_name <> 'PRIMARY'
-      GROUP BY table_schema, table_name, index_name, non_unique
-      `,
-      params
-    );
-
-    const tablesByKey = new Map<string, DatabaseTable>();
-
-    columnRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      if (!shouldIncludeTable(r.table_name, options)) return;
-      if (!tablesByKey.has(key)) {
-        tablesByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
-          columns: [],
-          primaryKey: pkMap.get(key) || [],
-          indexes: []
-        });
-      }
-      const cols = tablesByKey.get(key)!;
-      const column: DatabaseColumn = {
-        name: r.column_name,
-        type: r.data_type,
-        notNull: r.is_nullable === 'NO',
-        default: r.column_default ?? undefined,
-        autoIncrement: typeof r.extra === 'string' && r.extra.includes('auto_increment')
-      };
-      cols.columns.push(column);
-    });
-
-    indexRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      const table = tablesByKey.get(key);
-      if (!table) return;
-      const cols = (typeof r.cols === 'string' ? r.cols.split(',') : []).map((c: string) => ({ column: c.trim() }));
-      const idx: DatabaseIndex = {
-        name: r.index_name,
-        columns: cols,
-        unique: r.non_unique === 0
-      };
-      table.indexes = table.indexes || [];
-      table.indexes.push(idx);
-    });
-
-    return { tables: Array.from(tablesByKey.values()) };
-  }
-};
+import { SchemaIntrospector, IntrospectOptions } from './types.js';
+import { queryRows, shouldIncludeTable } from './utils.js';
+import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
+import { DbExecutor } from '../../execution/db-executor.js';
+
+export const mysqlIntrospector: SchemaIntrospector = {
+  async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const schema = options.schema;
+    const filterClause = schema ? 'table_schema = ?' : 'table_schema = database()';
+    const params = schema ? [schema] : [];
+
+    const columnRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default, extra
+      FROM information_schema.columns
+      WHERE ${filterClause}
+      ORDER BY table_name, ordinal_position
+      `,
+      params
+    );
+
+    const pkRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT table_schema, table_name, column_name
+      FROM information_schema.key_column_usage
+      WHERE constraint_name = 'PRIMARY' AND ${filterClause}
+      ORDER BY ordinal_position
+      `,
+      params
+    );
+
+    const pkMap = new Map<string, string[]>();
+    pkRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+
+    const indexRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        table_schema,
+        table_name,
+        index_name,
+        non_unique,
+        GROUP_CONCAT(column_name ORDER BY seq_in_index) AS cols
+      FROM information_schema.statistics
+      WHERE ${filterClause} AND index_name <> 'PRIMARY'
+      GROUP BY table_schema, table_name, index_name, non_unique
+      `,
+      params
+    );
+
+    const tablesByKey = new Map<string, DatabaseTable>();
+
+    columnRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key)!;
+      const column: DatabaseColumn = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === 'NO',
+        default: r.column_default ?? undefined,
+        autoIncrement: typeof r.extra === 'string' && r.extra.includes('auto_increment')
+      };
+      cols.columns.push(column);
+    });
+
+    indexRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (typeof r.cols === 'string' ? r.cols.split(',') : []).map((c: string) => ({ column: c.trim() }));
+      const idx: DatabaseIndex = {
+        name: r.index_name,
+        columns: cols,
+        unique: r.non_unique === 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};