@uql/core 3.1.1 → 3.1.3

package/src/migrate/namingStrategy.spec.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { Entity, Field, Id } from '../entity/index.js';
-import { SnakeCaseNamingStrategy } from '../index.js';
-import { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
-
-@Entity()
-class UserProfileMigrate {
-  @Id() id?: number;
-  @Field() firstName?: string;
-  @Field() lastName?: string;
-}
-
-describe('Schema Generator with Naming Strategy', () => {
-  it('should generate CREATE TABLE with translated names', () => {
-    const generator = new PostgresSchemaGenerator(new SnakeCaseNamingStrategy());
-    const sql = generator.generateCreateTable(UserProfileMigrate);
-
-    expect(sql).toContain('CREATE TABLE "user_profile_migrate"');
-    expect(sql).toContain('"first_name"');
-    expect(sql).toContain('"last_name"');
-  });
-});

package/src/migrate/schemaGenerator-advanced.spec.ts

@@ -1,138 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { Entity, Field, Id } from '../entity/index.js';
-import type { TableSchema } from '../type/index.js';
-import { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
-
-@Entity()
-class DiffUser {
-  @Id() id?: number;
-  @Field({ columnType: 'varchar', length: 255 }) name?: string;
-  @Field({ columnType: 'varchar', length: 100 }) email?: string;
-  @Field({ columnType: 'varchar', length: 255, index: true }) status?: string;
-}
-
-describe('AbstractSchemaGenerator (via Postgres)', () => {
-  const generator = new PostgresSchemaGenerator();
-
-  it('diffSchema should detect new columns', () => {
-    const currentSchema: TableSchema = {
-      name: 'DiffUser',
-      columns: [
-        { name: 'id', type: 'INTEGER', nullable: false, isPrimaryKey: true, isAutoIncrement: true, isUnique: false },
-        {
-          name: 'name',
-          type: 'VARCHAR',
-          length: 255,
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-      ],
-    };
-
-    const diff = generator.diffSchema(DiffUser, currentSchema);
-
-    expect(diff).toBeDefined();
-    expect(diff?.type).toBe('alter');
-    expect(diff?.columnsToAdd).toHaveLength(2);
-    expect(diff?.columnsToAdd?.[0].name).toBe('email');
-    expect(diff?.columnsToAdd?.[1].name).toBe('status');
-  });
-
-  it('diffSchema should detect altered columns (type change)', () => {
-    const currentSchema: TableSchema = {
-      name: 'DiffUser',
-      columns: [
-        { name: 'id', type: 'BIGINT', nullable: false, isPrimaryKey: true, isAutoIncrement: true, isUnique: false },
-        { name: 'name', type: 'TEXT', nullable: true, isPrimaryKey: false, isAutoIncrement: false, isUnique: false },
-        {
-          name: 'email',
-          type: 'VARCHAR',
-          length: 50,
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-        {
-          name: 'status',
-          type: 'VARCHAR',
-          length: 255,
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-      ],
-    };
-
-    const diff = generator.diffSchema(DiffUser, currentSchema);
-
-    expect(diff).toBeDefined();
-    expect(diff?.type).toBe('alter');
-    expect(diff?.columnsToAlter).toHaveLength(3);
-    expect(diff?.columnsToAlter?.[0].to.name).toBe('name');
-    expect(diff?.columnsToAlter?.[1].to.name).toBe('email');
-    expect(diff?.columnsToAlter?.[2].to.name).toBe('status');
-  });
-
-  it('diffSchema should detect columns to drop', () => {
-    const currentSchema: TableSchema = {
-      name: 'DiffUser',
-      columns: [
-        { name: 'id', type: 'INTEGER', nullable: false, isPrimaryKey: true, isAutoIncrement: true, isUnique: false },
-        { name: 'name', type: 'VARCHAR', nullable: true, isPrimaryKey: false, isAutoIncrement: false, isUnique: false },
-        {
-          name: 'email',
-          type: 'VARCHAR',
-          length: 100,
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-        {
-          name: 'status',
-          type: 'VARCHAR',
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-        {
-          name: 'old_col',
-          type: 'VARCHAR',
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-      ],
-    };
-
-    const diff = generator.diffSchema(DiffUser, currentSchema);
-
-    expect(diff).toBeDefined();
-    expect(diff?.type).toBe('alter');
-    expect(diff?.columnsToDrop).toEqual(['old_col']);
-  });
-
-  it('generateAlterTable should produce correct SQL', () => {
-    const sql = generator.generateAlterTable({
-      tableName: 'users',
-      type: 'alter',
-      columnsToAdd: [
-        { name: 'age', type: 'INTEGER', nullable: true, isPrimaryKey: false, isAutoIncrement: false, isUnique: false },
-      ],
-      columnsToDrop: ['old_name'],
-      indexesToAdd: [{ name: 'idx_age', columns: ['age'], unique: false }],
-      indexesToDrop: ['idx_old'],
-    });
-
-    expect(sql).toContain('ALTER TABLE "users" ADD COLUMN "age" INTEGER;');
-    expect(sql).toContain('ALTER TABLE "users" DROP COLUMN "old_name";');
-    expect(sql).toContain('CREATE INDEX "idx_age" ON "users" ("age");');
-    expect(sql).toContain('DROP INDEX IF EXISTS "idx_old";');
-  });
-});

package/src/migrate/schemaGenerator.spec.ts

@@ -1,190 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { Entity, Field, Id, ManyToOne } from '../entity/index.js';
-import { MysqlSchemaGenerator } from './generator/mysqlSchemaGenerator.js';
-import { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
-import { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
-
-// Test entities
-@Entity()
-class TestUser {
-  @Id()
-  id?: number;
-
-  @Field({ length: 100 })
-  name?: string;
-
-  @Field({ unique: true })
-  email?: string;
-
-  @Field({ nullable: false })
-  password?: string;
-
-  @Field({ onInsert: Date.now })
-  createdAt?: number;
-}
-
-@Entity({ name: 'blog_posts' })
-class TestPost {
-  @Id({ onInsert: () => crypto.randomUUID(), length: 36 })
-  id?: string;
-
-  @Field()
-  title?: string;
-
-  @Field({ columnType: 'text' })
-  content?: string;
-
-  @Field({ type: 'jsonb' })
-  metadata?: Record<string, unknown>;
-
-  @Field({ reference: () => TestUser })
-  authorId?: number;
-
-  @ManyToOne()
-  author?: TestUser;
-}
-
-describe('PostgresSchemaGenerator', () => {
-  const generator = new PostgresSchemaGenerator();
-
-  it('should generate CREATE TABLE for simple entity', () => {
-    const sql = generator.generateCreateTable(TestUser);
-
-    expect(sql).toContain('CREATE TABLE "TestUser"');
-    expect(sql).toContain('"id" SERIAL PRIMARY KEY');
-    expect(sql).toContain('"name" VARCHAR(100)');
-    expect(sql).toContain('"email" VARCHAR(255) UNIQUE');
-    expect(sql).toContain('"password" VARCHAR(255) NOT NULL');
-    expect(sql).toContain('"createdAt"');
-  });
-
-  it('should generate CREATE TABLE with UUID primary key', () => {
-    const sql = generator.generateCreateTable(TestPost);
-
-    expect(sql).toContain('CREATE TABLE "blog_posts"');
-    expect(sql).toContain('"id" VARCHAR(36) PRIMARY KEY');
-    expect(sql).toContain('"title" VARCHAR(255)');
-    expect(sql).toContain('"content" TEXT');
-    expect(sql).toContain('"metadata" JSONB');
-    expect(sql).toContain('"authorId"');
-  });
-
-  it('should generate DROP TABLE statement', () => {
-    const sql = generator.generateDropTable(TestUser);
-
-    expect(sql).toBe('DROP TABLE IF EXISTS "TestUser";');
-  });
-
-  it('should generate CREATE INDEX statement', () => {
-    const sql = generator.generateCreateIndex('users', {
-      name: 'idx_users_email',
-      columns: ['email'],
-      unique: true,
-    });
-
-    expect(sql).toBe('CREATE UNIQUE INDEX "idx_users_email" ON "users" ("email");');
-  });
-
-  it('should generate CREATE TABLE with IF NOT EXISTS', () => {
-    const sql = generator.generateCreateTable(TestUser, { ifNotExists: true });
-    expect(sql).toContain('CREATE TABLE IF NOT EXISTS "TestUser"');
-  });
-
-  it('should handle embedded quotes in table names', () => {
-    @Entity({ name: 'my"table' })
-    class TestEntity {
-      @Id()
-      id?: number;
-    }
-    const sql = generator.generateCreateTable(TestEntity);
-    expect(sql).toContain('CREATE TABLE "my""table"');
-  });
-
-  it('should handle already-typed column schemas', () => {
-    const sql = generator.generateAlterTable({
-      tableName: 'users',
-      type: 'alter',
-      columnsToAdd: [
-        {
-          name: 'profile_data',
-          type: 'JSONB',
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-      ],
-    });
-    // Should NOT be JSONB(JSONB)
-    expect(sql[0]).toContain('ADD COLUMN "profile_data" JSONB');
-    expect(sql[0]).not.toContain('JSONB(');
-  });
-
-  it('should generate ALTER TABLE DOWN statements', () => {
-    const sql = generator.generateAlterTableDown({
-      tableName: 'users',
-      type: 'alter',
-      columnsToAdd: [
-        {
-          name: 'profile_data',
-          type: 'JSONB',
-          nullable: true,
-          isPrimaryKey: false,
-          isAutoIncrement: false,
-          isUnique: false,
-        },
-      ],
-    });
-    expect(sql[0]).toBe('ALTER TABLE "users" DROP COLUMN "profile_data";');
-  });
-});
-
-describe('MysqlSchemaGenerator', () => {
-  const generator = new MysqlSchemaGenerator();
-
-  it('should generate CREATE TABLE for simple entity', () => {
-    const sql = generator.generateCreateTable(TestUser);
-
-    expect(sql).toContain('CREATE TABLE `TestUser`');
-    expect(sql).toContain('`id` INT AUTO_INCREMENT PRIMARY KEY');
-    expect(sql).toContain('`name` VARCHAR(100)');
-    expect(sql).toContain('`email` VARCHAR(255) UNIQUE');
-    expect(sql).toContain('ENGINE=InnoDB');
-  });
-
-  it('should generate boolean as TINYINT(1)', () => {
-    const boolType = generator.getSqlType({ type: Boolean }, Boolean);
-    expect(boolType).toBe('TINYINT(1)');
-  });
-
-  it('should generate DROP INDEX with ON table', () => {
-    const sql = generator.generateDropIndex('users', 'idx_email');
-    expect(sql).toBe('DROP INDEX `idx_email` ON `users`;');
-  });
-});
-
-describe('SqliteSchemaGenerator', () => {
-  const generator = new SqliteSchemaGenerator();
-
-  it('should generate CREATE TABLE for simple entity', () => {
-    const sql = generator.generateCreateTable(TestUser);
-
-    expect(sql).toContain('CREATE TABLE `TestUser`');
-    expect(sql).toContain('`id` INTEGER PRIMARY KEY AUTOINCREMENT');
-    // SQLite uses VARCHAR when length is specified, which is fine as SQLite has dynamic typing
-    expect(sql).toContain('`name` VARCHAR(100)');
-    expect(sql).toContain('`email` VARCHAR(255) UNIQUE');
-  });
-
-  it('should use TEXT for most types (SQLite dynamic typing)', () => {
-    expect(generator.getSqlType({ columnType: 'varchar' }, String)).toBe('TEXT');
-    expect(generator.getSqlType({ columnType: 'json' }, undefined)).toBe('TEXT');
-    expect(generator.getSqlType({ columnType: 'uuid' }, undefined)).toBe('TEXT');
-  });
-
-  it('should use INTEGER for numeric types', () => {
-    expect(generator.getSqlType({ columnType: 'int' }, undefined)).toBe('INTEGER');
-    expect(generator.getSqlType({ columnType: 'bigint' }, undefined)).toBe('INTEGER');
-    expect(generator.getSqlType({ type: Boolean }, Boolean)).toBe('INTEGER');
-  });
-});