@uql/core 3.1.1 → 3.1.2

package/src/migrate/generator/mongoSchemaGenerator.spec.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { Entity, Field, Id } from '../../entity/index.js';
-import type { IndexSchema, TableSchema } from '../../type/index.js';
-import { MongoSchemaGenerator } from './mongoSchemaGenerator.js';
-
-@Entity()
-class MongoUser {
-  @Id() id?: string;
-  @Field({ index: true }) username?: string;
-  @Field({ index: 'idx_email', unique: true }) email?: string;
-}
-
-describe('MongoSchemaGenerator', () => {
-  const generator = new MongoSchemaGenerator();
-
-  it('should generate createCollection statement', () => {
-    const json = generator.generateCreateTable(MongoUser);
-    const cmd = JSON.parse(json);
-
-    expect(cmd).toMatchObject({
-      action: 'createCollection',
-      name: 'MongoUser',
-    });
-    expect(cmd.indexes).toHaveLength(2);
-    expect(cmd.indexes).toContainEqual({
-      name: 'idx_MongoUser_username',
-      columns: ['username'],
-      unique: false,
-    });
-    expect(cmd.indexes).toContainEqual({
-      name: 'idx_email',
-      columns: ['email'],
-      unique: true,
-    });
-  });
-
-  it('should generate dropCollection statement', () => {
-    const json = generator.generateDropTable(MongoUser);
-    const cmd = JSON.parse(json);
-
-    expect(cmd).toMatchObject({
-      action: 'dropCollection',
-      name: 'MongoUser',
-    });
-  });
-
-  it('should generate createIndex statement', () => {
-    const json = generator.generateCreateIndex('MongoUser', {
-      name: 'idx_test',
-      columns: ['test'],
-      unique: true,
-    } as IndexSchema);
-    const cmd = JSON.parse(json);
-
-    expect(cmd).toMatchObject({
-      action: 'createIndex',
-      collection: 'MongoUser',
-      name: 'idx_test',
-      key: { test: 1 },
-      options: { unique: true, name: 'idx_test' },
-    });
-  });
-
-  it('should generate dropIndex statement', () => {
-    const json = generator.generateDropIndex('MongoUser', 'idx_test');
-    const cmd = JSON.parse(json);
-
-    expect(cmd).toMatchObject({
-      action: 'dropIndex',
-      collection: 'MongoUser',
-      name: 'idx_test',
-    });
-  });
-
-  it('diffSchema should return create if currentSchema is undefined', () => {
-    const diff = generator.diffSchema(MongoUser, undefined);
-    expect(diff).toMatchObject({
-      tableName: 'MongoUser',
-      type: 'create',
-    });
-  });
-
-  it('diffSchema should return alter if indexes are missing', () => {
-    const currentSchema: TableSchema = {
-      name: 'MongoUser',
-      columns: [],
-      indexes: [{ name: 'idx_MongoUser_username', columns: ['username'], unique: false }],
-    };
-
-    const diff = generator.diffSchema(MongoUser, currentSchema);
-    expect(diff).toMatchObject({
-      tableName: 'MongoUser',
-      type: 'alter',
-    });
-    expect(diff?.indexesToAdd).toHaveLength(1);
-    expect(diff?.indexesToAdd?.[0].name).toBe('idx_email');
-  });
-
-  it('diffSchema should return undefined if in sync', () => {
-    const currentSchema: import('../../type/index.js').TableSchema = {
-      name: 'MongoUser',
-      columns: [],
-      indexes: [
-        { name: 'idx_MongoUser_username', columns: ['username'], unique: false },
-        { name: 'idx_email', columns: ['email'], unique: true },
-      ],
-    };
-
-    const diff = generator.diffSchema(MongoUser, currentSchema);
-    expect(diff).toBeUndefined();
-  });
-});

package/src/migrate/generator/mongoSchemaGenerator.ts

@@ -1,115 +0,0 @@
-import { AbstractDialect } from '../../dialect/index.js';
-import { getMeta } from '../../entity/index.js';
-import type { IndexSchema, SchemaDiff, SchemaGenerator, TableSchema, Type } from '../../type/index.js';
-
-export class MongoSchemaGenerator extends AbstractDialect implements SchemaGenerator {
-  generateCreateTable<E>(entity: Type<E>): string {
-    const meta = getMeta(entity);
-    const collectionName = this.resolveTableName(entity, meta);
-    const indexes: IndexSchema[] = [];
-
-    for (const key in meta.fields) {
-      const field = meta.fields[key];
-      if (field.index) {
-        const columnName = this.resolveColumnName(key, field);
-        const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
-        indexes.push({
-          name: indexName,
-          columns: [columnName],
-          unique: !!field.unique,
-        });
-      }
-    }
-
-    return JSON.stringify({ action: 'createCollection', name: collectionName, indexes });
-  }
-
-  generateDropTable<E>(entity: Type<E>): string {
-    const meta = getMeta(entity);
-    const collectionName = this.resolveTableName(entity, meta);
-    return JSON.stringify({ action: 'dropCollection', name: collectionName });
-  }
-
-  generateAlterTable(diff: SchemaDiff): string[] {
-    const statements: string[] = [];
-    if (diff.indexesToAdd?.length) {
-      for (const index of diff.indexesToAdd) {
-        statements.push(this.generateCreateIndex(diff.tableName, index));
-      }
-    }
-    return statements;
-  }
-
-  generateAlterTableDown(diff: SchemaDiff): string[] {
-    const statements: string[] = [];
-    if (diff.indexesToAdd?.length) {
-      for (const index of diff.indexesToAdd) {
-        statements.push(this.generateDropIndex(diff.tableName, index.name));
-      }
-    }
-    return statements;
-  }
-
-  generateCreateIndex(tableName: string, index: IndexSchema): string {
-    const key: Record<string, number> = {};
-    for (const col of index.columns) {
-      key[col] = 1;
-    }
-    return JSON.stringify({
-      action: 'createIndex',
-      collection: tableName,
-      name: index.name,
-      key,
-      options: { unique: index.unique, name: index.name },
-    });
-  }
-
-  generateDropIndex(tableName: string, indexName: string): string {
-    return JSON.stringify({
-      action: 'dropIndex',
-      collection: tableName,
-      name: indexName,
-    });
-  }
-
-  getSqlType(): string {
-    return '';
-  }
-
-  diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined {
-    const meta = getMeta(entity);
-    const collectionName = this.resolveTableName(entity, meta);
-
-    if (!currentSchema) {
-      return { tableName: collectionName, type: 'create' };
-    }
-
-    const indexesToAdd: IndexSchema[] = [];
-    const existingIndexes = new Set(currentSchema.indexes?.map((i: IndexSchema) => i.name) ?? []);
-
-    for (const key in meta.fields) {
-      const field = meta.fields[key];
-      if (field.index) {
-        const columnName = this.resolveColumnName(key, field);
-        const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
-        if (!existingIndexes.has(indexName)) {
-          indexesToAdd.push({
-            name: indexName,
-            columns: [columnName],
-            unique: !!field.unique,
-          });
-        }
-      }
-    }
-
-    if (indexesToAdd.length === 0) {
-      return undefined;
-    }
-
-    return {
-      tableName: collectionName,
-      type: 'alter',
-      indexesToAdd,
-    };
-  }
-}

package/src/migrate/generator/mysqlSchemaGenerator.spec.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { MysqlSchemaGenerator } from './mysqlSchemaGenerator.js';
-
-describe('MysqlSchemaGenerator Specifics', () => {
-  const generator = new MysqlSchemaGenerator();
-
-  it('should map column types correctly', () => {
-    expect(generator.getSqlType({ columnType: 'varchar', length: 100 }, String)).toBe('VARCHAR(100)');
-    expect(generator.getSqlType({ columnType: 'text' }, String)).toBe('TEXT');
-    expect(generator.getSqlType({ columnType: 'int' }, Number)).toBe('INT');
-    expect(generator.getSqlType({ columnType: 'bigint' }, Number)).toBe('BIGINT');
-    expect(generator.getSqlType({ type: Boolean }, Boolean)).toBe('TINYINT(1)');
-    expect(generator.getSqlType({ columnType: 'decimal', precision: 10, scale: 2 }, Number)).toBe('DECIMAL(10, 2)');
-  });
-
-  it('should generate ALTER COLUMN statements', () => {
-    const col = {
-      name: 'age',
-      type: 'INT',
-      nullable: false,
-      defaultValue: 18,
-      isPrimaryKey: false,
-      isAutoIncrement: false,
-      isUnique: false,
-    };
-    const statements = generator.generateAlterColumnStatements('users', col, 'INT NOT NULL DEFAULT 18');
-
-    expect(statements).toEqual(['ALTER TABLE `users` MODIFY COLUMN INT NOT NULL DEFAULT 18;']);
-  });
-
-  it('should get table options', () => {
-    expect(generator.getTableOptions()).toContain('ENGINE=InnoDB');
-  });
-});

package/src/migrate/generator/mysqlSchemaGenerator.ts

@@ -1,92 +0,0 @@
-import type { ColumnSchema, ColumnType, FieldOptions } from '../../type/index.js';
-import { AbstractSchemaGenerator } from '../schemaGenerator.js';
-
-/**
- * MySQL/MariaDB-specific schema generator
- */
-export class MysqlSchemaGenerator extends AbstractSchemaGenerator {
-  protected readonly serialPrimaryKeyType = 'INT AUTO_INCREMENT PRIMARY KEY';
-
-  public override mapColumnType(columnType: ColumnType, field: FieldOptions): string {
-    switch (columnType) {
-      case 'int':
-        return 'INT';
-      case 'smallint':
-        return 'SMALLINT';
-      case 'bigint':
-        return 'BIGINT';
-      case 'float':
-        return 'FLOAT';
-      case 'double':
-      case 'real':
-        return 'DOUBLE';
-      case 'decimal':
-      case 'numeric':
-        if (field.precision !== undefined) {
-          if (field.scale !== undefined) {
-            return `DECIMAL(${field.precision}, ${field.scale})`;
-          }
-          return `DECIMAL(${field.precision})`;
-        }
-        return 'DECIMAL(10, 2)';
-      case 'boolean':
-        return 'TINYINT(1)';
-      case 'char':
-        return `CHAR(${field.length ?? 1})`;
-      case 'varchar':
-        return `VARCHAR(${field.length ?? 255})`;
-      case 'text':
-        return 'TEXT';
-      case 'uuid':
-        return 'CHAR(36)';
-      case 'date':
-        return 'DATE';
-      case 'time':
-        return 'TIME';
-      case 'timestamp':
-      case 'timestamptz':
-        return 'TIMESTAMP';
-      case 'json':
-      case 'jsonb':
-        return 'JSON';
-      case 'blob':
-      case 'bytea':
-        return 'BLOB';
-      case 'vector':
-        // MySQL doesn't have native vector support, use JSON
-        return 'JSON';
-      case 'serial':
-        return 'INT AUTO_INCREMENT';
-      case 'bigserial':
-        return 'BIGINT AUTO_INCREMENT';
-      default:
-        return 'TEXT';
-    }
-  }
-
-  public override getBooleanType(): string {
-    return 'TINYINT(1)';
-  }
-
-  public override generateAlterColumnStatements(
-    tableName: string,
-    column: ColumnSchema,
-    newDefinition: string,
-  ): string[] {
-    return [`ALTER TABLE ${this.escapeId(tableName)} MODIFY COLUMN ${newDefinition};`];
-  }
-
-  public override generateColumnComment(tableName: string, columnName: string, comment: string): string {
-    const escapedComment = comment.replace(/'/g, "''");
-    return ` COMMENT '${escapedComment}'`;
-  }
-
-  override getTableOptions<E>(): string {
-    return ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
-  }
-
-  override generateDropIndex(tableName: string, indexName: string): string {
-    // MySQL requires table name in DROP INDEX
-    return `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)};`;
-  }
-}

package/src/migrate/generator/postgresSchemaGenerator.spec.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { PostgresSchemaGenerator } from './postgresSchemaGenerator.js';
-
-describe('PostgresSchemaGenerator Specifics', () => {
-  const generator = new PostgresSchemaGenerator();
-
-  it('should format default values correctly', () => {
-    expect(generator.formatDefaultValue('test')).toBe("'test'");
-    expect(generator.formatDefaultValue(123)).toBe('123');
-    expect(generator.formatDefaultValue(true)).toBe('TRUE');
-    expect(generator.formatDefaultValue(false)).toBe('FALSE');
-    expect(generator.formatDefaultValue(null)).toBe('NULL');
-  });
-
-  it('should map column types correctly', () => {
-    expect(generator.getSqlType({ columnType: 'varchar', length: 100 }, String)).toBe('VARCHAR(100)');
-    expect(generator.getSqlType({ columnType: 'text' }, String)).toBe('TEXT');
-    expect(generator.getSqlType({ columnType: 'int' }, Number)).toBe('INTEGER');
-    expect(generator.getSqlType({ columnType: 'bigint' }, Number)).toBe('BIGINT');
-    expect(generator.getSqlType({ type: Boolean }, Boolean)).toBe('BOOLEAN');
-    expect(generator.getSqlType({ columnType: 'decimal', precision: 10, scale: 2 }, Number)).toBe('NUMERIC(10, 2)');
-  });
-
-  it('should generate DROP INDEX statement', () => {
-    expect(generator.generateDropIndex('users', 'idx_test')).toBe('DROP INDEX IF EXISTS "idx_test";');
-  });
-
-  it('should generate ALTER COLUMN statements', () => {
-    const col = {
-      name: 'age',
-      type: 'INTEGER',
-      nullable: false,
-      defaultValue: 18,
-      isPrimaryKey: false,
-      isAutoIncrement: false,
-      isUnique: false,
-    };
-    const statements = generator.generateAlterColumnStatements('users', col, 'INTEGER');
-
-    expect(statements).toContain('ALTER TABLE "users" ALTER COLUMN "age" TYPE INTEGER;');
-    expect(statements).toContain('ALTER TABLE "users" ALTER COLUMN "age" SET NOT NULL;');
-    expect(statements).toContain('ALTER TABLE "users" ALTER COLUMN "age" SET DEFAULT 18;');
-  });
-});

package/src/migrate/generator/postgresSchemaGenerator.ts

@@ -1,127 +0,0 @@
-import type { ColumnSchema, ColumnType, FieldOptions, NamingStrategy } from '../../type/index.js';
-import { AbstractSchemaGenerator } from '../schemaGenerator.js';
-
-/**
- * PostgreSQL-specific schema generator
- */
-export class PostgresSchemaGenerator extends AbstractSchemaGenerator {
-  protected readonly serialPrimaryKeyType = 'SERIAL PRIMARY KEY';
-
-  constructor(namingStrategy?: NamingStrategy) {
-    super(namingStrategy, '"');
-  }
-
-  public override mapColumnType(columnType: ColumnType, field: FieldOptions): string {
-    switch (columnType) {
-      case 'int':
-        return 'INTEGER';
-      case 'smallint':
-        return 'SMALLINT';
-      case 'bigint':
-        return 'BIGINT';
-      case 'float':
-      case 'double':
-      case 'real':
-        return 'DOUBLE PRECISION';
-      case 'decimal':
-      case 'numeric':
-        if (field.precision !== undefined) {
-          if (field.scale !== undefined) {
-            return `NUMERIC(${field.precision}, ${field.scale})`;
-          }
-          return `NUMERIC(${field.precision})`;
-        }
-        return 'NUMERIC';
-      case 'boolean':
-        return 'BOOLEAN';
-      case 'char':
-        return `CHAR(${field.length ?? 1})`;
-      case 'varchar':
-        return `VARCHAR(${field.length ?? 255})`;
-      case 'text':
-        return 'TEXT';
-      case 'uuid':
-        return 'UUID';
-      case 'date':
-        return 'DATE';
-      case 'time':
-        return 'TIME';
-      case 'timestamp':
-        return 'TIMESTAMP';
-      case 'timestamptz':
-        return 'TIMESTAMPTZ';
-      case 'json':
-        return 'JSON';
-      case 'jsonb':
-        return 'JSONB';
-      case 'blob':
-      case 'bytea':
-        return 'BYTEA';
-      case 'vector':
-        if (field.length) {
-          return `VECTOR(${field.length})`;
-        }
-        return 'VECTOR';
-      case 'serial':
-        return 'SERIAL';
-      case 'bigserial':
-        return 'BIGSERIAL';
-      default:
-        return 'TEXT';
-    }
-  }
-
-  public override getBooleanType(): string {
-    return 'BOOLEAN';
-  }
-
-  public override generateAlterColumnStatements(
-    tableName: string,
-    column: ColumnSchema,
-    newDefinition: string,
-  ): string[] {
-    const statements: string[] = [];
-    const escapedTableName = this.escapeId(tableName);
-    const escapedColumnName = this.escapeId(column.name);
-
-    // PostgreSQL uses separate ALTER COLUMN clauses for different changes
-    // 1. Change type
-    statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} TYPE ${column.type};`);
-
-    // 2. Change nullability
-    if (column.nullable) {
-      statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP NOT NULL;`);
-    } else {
-      statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET NOT NULL;`);
-    }
-
-    // 3. Change default value
-    if (column.defaultValue !== undefined) {
-      statements.push(
-        `ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`,
-      );
-    } else {
-      statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP DEFAULT;`);
-    }
-
-    return statements;
-  }
-
-  public override generateColumnComment(tableName: string, columnName: string, comment: string): string {
-    // PostgreSQL handles comments separately via COMMENT ON COLUMN
-    return '';
-  }
-
-  /**
-   * Generate COMMENT ON COLUMN statement for PostgreSQL
-   */
-  generateColumnCommentStatement(tableName: string, columnName: string, comment: string): string {
-    const escapedComment = comment.replace(/'/g, "''");
-    return `COMMENT ON COLUMN ${this.escapeId(tableName)}.${this.escapeId(columnName)} IS '${escapedComment}';`;
-  }
-
-  override generateDropIndex(tableName: string, indexName: string): string {
-    // PostgreSQL doesn't require table name in DROP INDEX
-    return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
-  }
-}

package/src/migrate/generator/sqliteSchemaGenerator.spec.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { SqliteSchemaGenerator } from './sqliteSchemaGenerator.js';
-
-describe('SqliteSchemaGenerator Specifics', () => {
-  const generator = new SqliteSchemaGenerator();
-
-  it('should map column types correctly', () => {
-    expect(generator.getSqlType({ columnType: 'varchar', length: 100 }, String)).toBe('TEXT');
-    expect(generator.getSqlType({ columnType: 'int' }, Number)).toBe('INTEGER');
-    expect(generator.getSqlType({ type: Boolean }, Boolean)).toBe('INTEGER');
-  });
-
-  it('should throw error on generateAlterColumnStatements', () => {
-    const col = {
-      name: 'age',
-      type: 'INTEGER',
-      nullable: false,
-      isPrimaryKey: false,
-      isAutoIncrement: false,
-      isUnique: false,
-    };
-    expect(() => generator.generateAlterColumnStatements('users', col, 'INTEGER')).toThrow(
-      'SQLite does not support altering column',
-    );
-  });
-
-  it('should format default values correctly', () => {
-    expect(generator.formatDefaultValue('test')).toBe("'test'");
-    expect(generator.formatDefaultValue(123)).toBe('123');
-    expect(generator.formatDefaultValue(true)).toBe('1');
-    expect(generator.formatDefaultValue(false)).toBe('0');
-  });
-});

package/src/migrate/generator/sqliteSchemaGenerator.ts

@@ -1,81 +0,0 @@
-import type { ColumnSchema, ColumnType, FieldOptions } from '../../type/index.js';
-import { AbstractSchemaGenerator } from '../schemaGenerator.js';
-
-/**
- * SQLite-specific schema generator
- */
-export class SqliteSchemaGenerator extends AbstractSchemaGenerator {
-  protected readonly serialPrimaryKeyType = 'INTEGER PRIMARY KEY AUTOINCREMENT';
-
-  public override mapColumnType(columnType: ColumnType, field: FieldOptions): string {
-    // SQLite has dynamic typing, but we use type affinity
-    switch (columnType) {
-      case 'int':
-      case 'smallint':
-      case 'bigint':
-      case 'serial':
-      case 'bigserial':
-        return 'INTEGER';
-      case 'float':
-      case 'double':
-      case 'real':
-      case 'decimal':
-      case 'numeric':
-        return 'REAL';
-      case 'boolean':
-        return 'INTEGER'; // SQLite uses 0/1 for booleans
-      case 'char':
-      case 'varchar':
-      case 'text':
-      case 'uuid':
-        return 'TEXT';
-      case 'date':
-      case 'time':
-      case 'timestamp':
-      case 'timestamptz':
-        return 'TEXT'; // SQLite stores dates as TEXT or INTEGER
-      case 'json':
-      case 'jsonb':
-        return 'TEXT'; // SQLite stores JSON as TEXT
-      case 'blob':
-      case 'bytea':
-        return 'BLOB';
-      case 'vector':
-        return 'TEXT'; // Store as JSON array
-      default:
-        return 'TEXT';
-    }
-  }
-
-  public override getBooleanType(): string {
-    return 'INTEGER';
-  }
-
-  public override generateAlterColumnStatements(
-    tableName: string,
-    column: ColumnSchema,
-    newDefinition: string,
-  ): string[] {
-    // SQLite has very limited ALTER TABLE support
-    // Column type changes require recreating the table
-    throw new Error(
-      `SQLite does not support altering column '${column.name}' in table '${tableName}'. ` +
-        'You need to recreate the table to change column types.',
-    );
-  }
-
-  public override generateColumnComment(tableName: string, columnName: string, comment: string): string {
-    return '';
-  }
-
-  override generateDropIndex(tableName: string, indexName: string): string {
-    return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
-  }
-
-  override formatDefaultValue(value: unknown): string {
-    if (typeof value === 'boolean') {
-      return value ? '1' : '0';
-    }
-    return super.formatDefaultValue(value);
-  }
-}

package/src/migrate/index.ts

@@ -1,41 +0,0 @@
-// Core types
-
-// Re-export core types for convenience
-// Migration-specific types
-export type {
-  ColumnSchema,
-  Dialect,
-  ForeignKeySchema,
-  IndexSchema,
-  Migration,
-  MigrationDefinition,
-  MigrationResult,
-  MigrationStorage,
-  MigratorOptions,
-  MongoQuerier,
-  SchemaDiff,
-  SchemaGenerator,
-  SchemaIntrospector,
-  SqlDialect,
-  SqlQuerier,
-  SqlQueryDialect,
-  TableSchema,
-} from '../type/index.js';
-export { isSqlQuerier } from '../type/index.js';
-export {
-  MysqlSchemaGenerator,
-  MysqlSchemaGenerator as MariadbSchemaGenerator,
-} from './generator/mysqlSchemaGenerator.js';
-export { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
-export { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
-// Schema introspection
-export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './introspection/mysqlIntrospector.js';
-export { PostgresSchemaIntrospector } from './introspection/postgresIntrospector.js';
-export { SqliteSchemaIntrospector } from './introspection/sqliteIntrospector.js';
-// Main migrator
-export { defineMigration, Migrator } from './migrator.js';
-// Schema generators
-export { AbstractSchemaGenerator } from './schemaGenerator.js';
-// Storage implementations
-export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
-export { JsonMigrationStorage } from './storage/jsonStorage.js';

package/src/migrate/introspection/index.ts

@@ -1,4 +0,0 @@
-export * from './mongoIntrospector.js';
-export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
-export * from './postgresIntrospector.js';
-export * from './sqliteIntrospector.js';