@uql/core 3.1.1 → 3.1.3

package/src/maria/mariaDialect.spec.ts

@@ -1,207 +0,0 @@
-import { expect } from 'bun:test';
-import { AbstractSqlDialectSpec } from '../dialect/abstractSqlDialect-spec.js';
-import { InventoryAdjustment, ItemTag, TaxCategory, User } from '../test/index.js';
-import { createSpec } from '../test/spec.util.js';
-import type { FieldKey } from '../type/index.js';
-import { MariaDialect } from './mariaDialect.js';
-
-export class MariaDialectSpec extends AbstractSqlDialectSpec {
-  constructor() {
-    super(new MariaDialect());
-  }
-
-  shouldHandleDate() {
-    const dialect = new MariaDialect();
-    const values: unknown[] = [];
-    expect(dialect.addValue(values, new Date())).toBe('?');
-    expect(values).toHaveLength(1);
-    expect(values[0]).toBeInstanceOf(Date);
-  }
-
-  shouldUpsertWithNoUpdateFields() {
-    const { sql } = this.exec((ctx) => this.dialect.upsert(ctx, ItemTag, { id: true }, { id: 123 }));
-    expect(sql).toContain('INSERT IGNORE');
-  }
-
-  override shouldInsertMany() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.insert(ctx, User, [
-        {
-          name: 'Some name 1',
-          email: 'someemail1@example.com',
-          createdAt: 123,
-        },
-        {
-          name: 'Some name 2',
-          email: 'someemail2@example.com',
-          createdAt: 456,
-        },
-        {
-          name: 'Some name 3',
-          email: 'someemail3@example.com',
-          createdAt: 789,
-        },
-      ]),
-    );
-    expect(sql).toBe(
-      'INSERT INTO `User` (`name`, `email`, `createdAt`) VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?) RETURNING `id` `id`',
-    );
-    expect(values).toEqual([
-      'Some name 1',
-      'someemail1@example.com',
-      123,
-      'Some name 2',
-      'someemail2@example.com',
-      456,
-      'Some name 3',
-      'someemail3@example.com',
-      789,
-    ]);
-  }
-
-  override shouldBeSecure() {
-    let res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: ['id', 'something' as FieldKey<User>],
-        $where: {
-          id: 1,
-          something: 1,
-        } as any,
-        $sort: {
-          id: 1,
-          something: 1,
-        } as any,
-      }),
-    );
-    expect(res.sql).toBe('SELECT `id` FROM `User` WHERE `id` = ? AND `something` = ? ORDER BY `id`, `something`');
-    expect(res.values).toEqual([1, 1]);
-
-    res = this.exec((ctx) =>
-      this.dialect.insert(ctx, User, {
-        name: 'Some Name',
-        something: 'anything',
-        createdAt: 1,
-      } as any),
-    );
-    expect(res.sql).toBe('INSERT INTO `User` (`name`, `createdAt`) VALUES (?, ?) RETURNING `id` `id`');
-    expect(res.values).toEqual(['Some Name', 1]);
-
-    res = this.exec((ctx) =>
-      this.dialect.update(
-        ctx,
-        User,
-        {
-          $where: { something: 'anything' },
-        },
-        {
-          name: 'Some Name',
-          something: 'anything',
-          updatedAt: 1,
-        } as any,
-      ),
-    );
-    expect(res.sql).toBe('UPDATE `User` SET `name` = ?, `updatedAt` = ? WHERE `something` = ?');
-    expect(res.values).toEqual(['Some Name', 1, 'anything']);
-
-    res = this.exec((ctx) =>
-      this.dialect.delete(ctx, User, {
-        $where: { something: 'anything' } as any,
-      }),
-    );
-    expect(res.sql).toBe('DELETE FROM `User` WHERE `something` = ?');
-    expect(res.values).toEqual(['anything']);
-  }
-
-  override shouldUpsert() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        User,
-        { email: true },
-        {
-          name: 'Some Name',
-          email: 'someemail@example.com',
-          createdAt: 123,
-        },
-      ),
-    );
-    expect(sql).toBe(
-      'INSERT INTO `User` (`name`, `email`, `createdAt`, `updatedAt`) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE `name` = VALUES(`name`), `createdAt` = VALUES(`createdAt`), `updatedAt` = VALUES(`updatedAt`) RETURNING `id` `id`',
-    );
-    expect(values).toEqual(['Some Name', 'someemail@example.com', 123, expect.any(Number)]);
-  }
-
-  override shouldInsertManyWithSpecifiedIdsAndOnInsertIdAsDefault() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.insert(ctx, TaxCategory, [
-        {
-          name: 'Some Name A',
-        },
-        {
-          pk: '50',
-          name: 'Some Name B',
-        },
-        {
-          name: 'Some Name C',
-        },
-        {
-          pk: '70',
-          name: 'Some Name D',
-        },
-      ]),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO `TaxCategory` \(`name`, `createdAt`, `pk`\) VALUES \(\?, \?, \?\), \(\?, \?, \?\), \(\?, \?, \?\), \(\?, \?, \?\) RETURNING `pk` `id`$/,
-    );
-    expect(values).toEqual([
-      'Some Name A',
-      expect.any(Number),
-      expect.any(String),
-      'Some Name B',
-      expect.any(Number),
-      '50',
-      'Some Name C',
-      expect.any(Number),
-      expect.any(String),
-      'Some Name D',
-      expect.any(Number),
-      '70',
-    ]);
-  }
-
-  override shouldInsertOne() {
-    let res = this.exec((ctx) =>
-      this.dialect.insert(ctx, User, {
-        name: 'Some Name',
-        email: 'someemail@example.com',
-        createdAt: 123,
-      }),
-    );
-    expect(res.sql).toBe('INSERT INTO `User` (`name`, `email`, `createdAt`) VALUES (?, ?, ?) RETURNING `id` `id`');
-    expect(res.values).toEqual(['Some Name', 'someemail@example.com', 123]);
-
-    res = this.exec((ctx) =>
-      this.dialect.insert(ctx, InventoryAdjustment, {
-        date: new Date(2021, 11, 31, 23, 59, 59, 999),
-        createdAt: 123,
-      }),
-    );
-    expect(res.sql).toBe('INSERT INTO `InventoryAdjustment` (`date`, `createdAt`) VALUES (?, ?) RETURNING `id` `id`');
-    expect(res.values).toEqual([new Date(2021, 11, 31, 23, 59, 59, 999), 123]);
-  }
-
-  override shouldInsertWithOnInsertId() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.insert(ctx, TaxCategory, {
-        name: 'Some Name',
-        createdAt: 123,
-      }),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO `TaxCategory` \(`name`, `createdAt`, `pk`\) VALUES \(\?, \?, \?\) RETURNING `pk` `id`$/,
-    );
-    expect(values).toEqual(['Some Name', 123, expect.any(String)]);
-  }
-}
-
-createSpec(new MariaDialectSpec());

package/src/maria/mariaDialect.ts

@@ -1,42 +0,0 @@
-import SqlString from 'sqlstring';
-import { AbstractSqlDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import type { QueryConflictPaths, QueryContext, QueryOptions, Type } from '../type/index.js';
-
-export class MariaDialect extends AbstractSqlDialect {
-  override addValue(values: unknown[], value: unknown): string {
-    if (value instanceof Date) {
-      values.push(value);
-      return '?';
-    }
-    return super.addValue(values, value);
-  }
-
-  override insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void {
-    super.insert(ctx, entity, payload, opts);
-    ctx.append(' ' + this.returningId(entity));
-  }
-
-  override upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void {
-    const meta = getMeta(entity);
-    const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name) => `VALUES(${name})`);
-    const returning = this.returningId(entity);
-
-    if (update) {
-      super.insert(ctx, entity, payload);
-      ctx.append(` ON DUPLICATE KEY UPDATE ${update} ${returning}`);
-    } else {
-      const insertCtx = this.createContext();
-      super.insert(insertCtx, entity, payload);
-      ctx.append(insertCtx.sql.replace(/^INSERT/, 'INSERT IGNORE'));
-      ctx.append(' ' + returning);
-      insertCtx.values.forEach((val) => {
-        ctx.pushValue(val);
-      });
-    }
-  }
-
-  override escape(value: unknown): string {
-    return SqlString.escape(value);
-  }
-}

package/src/maria/mariaQuerierPool.test.ts

@@ -1,23 +0,0 @@
-import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
-import { createSpec } from '../test/index.js';
-import type { MariadbQuerier } from './mariadbQuerier.js';
-import { MariadbQuerierPool } from './mariadbQuerierPool.js';
-
-export class MariadbQuerierPoolIt extends AbstractQuerierPoolIt<MariadbQuerier> {
-  constructor() {
-    super(
-      new MariadbQuerierPool({
-        host: '0.0.0.0',
-        port: 3326,
-        user: 'test',
-        password: 'test',
-        database: 'test',
-        connectionLimit: 5,
-        trace: true,
-        bigIntAsNumber: true,
-      }),
-    );
-  }
-}
-
-createSpec(new MariadbQuerierPoolIt());

package/src/maria/mariadbQuerier.test.ts

@@ -1,23 +0,0 @@
-import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
-import { createSpec } from '../test/index.js';
-import { MariadbQuerierPool } from './mariadbQuerierPool.js';
-
-export class MariadbQuerierIt extends AbstractSqlQuerierIt {
-  constructor() {
-    super(
-      new MariadbQuerierPool({
-        host: '0.0.0.0',
-        port: 3326,
-        user: 'test',
-        password: 'test',
-        database: 'test',
-        connectionLimit: 5,
-        trace: true,
-        bigIntAsNumber: true,
-      }),
-      'INT AUTO_INCREMENT PRIMARY KEY',
-    );
-  }
-}
-
-createSpec(new MariadbQuerierIt());

package/src/maria/mariadbQuerier.ts

@@ -1,45 +0,0 @@
-import type { PoolConnection } from 'mariadb';
-import { AbstractSqlQuerier } from '../querier/index.js';
-import type { ExtraOptions, QueryUpdateResult } from '../type/index.js';
-import { MariaDialect } from './mariaDialect.js';
-
-export class MariadbQuerier extends AbstractSqlQuerier {
-  conn: PoolConnection;
-
-  constructor(
-    readonly connect: () => Promise<PoolConnection>,
-    readonly extra?: ExtraOptions,
-  ) {
-    super(new MariaDialect(extra?.namingStrategy));
-  }
-
-  override async internalAll<T>(query: string, values?: unknown[]) {
-    this.extra?.logger?.(query, values);
-    await this.lazyConnect();
-    const res: T[] = await this.conn.query(query, values);
-    return res.slice(0, res.length);
-  }
-
-  override async internalRun(query: string, values?: unknown[]) {
-    this.extra?.logger?.(query, values);
-    await this.lazyConnect();
-    const res = await this.conn.query(query, values);
-    const ids = res.length ? res.map((r: any) => r.id) : [];
-    return { changes: res.affectedRows, ids, firstId: ids[0] } satisfies QueryUpdateResult;
-  }
-
-  async lazyConnect() {
-    this.conn ??= await this.connect();
-  }
-
-  override async internalRelease() {
-    if (this.hasOpenTransaction) {
-      throw TypeError('pending transaction');
-    }
-    if (!this.conn) {
-      return;
-    }
-    await this.conn.release();
-    this.conn = undefined;
-  }
-}

package/src/maria/mariadbQuerierPool.ts

@@ -1,21 +0,0 @@
-import { createPool, type Pool, type PoolConfig } from 'mariadb';
-import { AbstractQuerierPool } from '../querier/index.js';
-import type { ExtraOptions } from '../type/index.js';
-import { MariadbQuerier } from './mariadbQuerier.js';
-
-export class MariadbQuerierPool extends AbstractQuerierPool<MariadbQuerier> {
-  readonly pool: Pool;
-
-  constructor(opts: PoolConfig, extra?: ExtraOptions) {
-    super('mariadb', extra);
-    this.pool = createPool(opts);
-  }
-
-  async getQuerier() {
-    return new MariadbQuerier(() => this.pool.getConnection(), this.extra);
-  }
-
-  async end() {
-    await this.pool.end();
-  }
-}

package/src/migrate/cli.ts

@@ -1,301 +0,0 @@
-#!/usr/bin/env node
-
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import type { Dialect, MigratorOptions, NamingStrategy, QuerierPool } from '../type/index.js';
-import { MongoSchemaGenerator } from './generator/mongoSchemaGenerator.js';
-import { MysqlSchemaGenerator } from './generator/mysqlSchemaGenerator.js';
-import { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
-import { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
-import { Migrator } from './migrator.js';
-
-interface CliConfig {
-  querierPool?: QuerierPool;
-  migrationsPath?: string;
-  tableName?: string;
-  dialect?: Dialect;
-  entities?: unknown[];
-  namingStrategy?: NamingStrategy;
-}
-
-async function loadConfig(): Promise<CliConfig> {
-  const configPaths = ['uql.config.ts', 'uql.config.js', 'uql.config.mjs', '.uqlrc.ts', '.uqlrc.js'];
-
-  for (const configPath of configPaths) {
-    try {
-      const fullPath = resolve(process.cwd(), configPath);
-      const fileUrl = pathToFileURL(fullPath).href;
-      const module = await import(fileUrl);
-      return module.default ?? module;
-    } catch {
-      // Config file not found, try next one
-    }
-  }
-
-  throw new Error(
-    'Could not find uql configuration file. ' + 'Create a uql.config.ts or uql.config.js file in your project root.',
-  );
-}
-
-function getSchemaGenerator(dialect: Dialect, namingStrategy?: NamingStrategy) {
-  switch (dialect) {
-    case 'postgres':
-      return new PostgresSchemaGenerator(namingStrategy);
-    case 'mysql':
-    case 'mariadb':
-      return new MysqlSchemaGenerator(namingStrategy);
-    case 'sqlite':
-      return new SqliteSchemaGenerator(namingStrategy);
-    case 'mongodb':
-      return new MongoSchemaGenerator(namingStrategy);
-    default:
-      throw new TypeError(`Unknown dialect: ${dialect}`);
-  }
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === '--help' || command === '-h') {
-    printHelp();
-    return;
-  }
-
-  try {
-    const config = await loadConfig();
-
-    if (!config.querierPool) {
-      throw new Error('querierPool is required in configuration');
-    }
-
-    const dialect = config.dialect ?? 'postgres';
-
-    const options: MigratorOptions & { dialect: Dialect } = {
-      migrationsPath: config.migrationsPath ?? './migrations',
-      tableName: config.tableName,
-      logger: console.log,
-      entities: config.entities as MigratorOptions['entities'],
-      dialect,
-      namingStrategy: config.namingStrategy,
-    };
-
-    const migrator = new Migrator(config.querierPool, options);
-    migrator.setSchemaGenerator(getSchemaGenerator(dialect, config.namingStrategy));
-
-    switch (command) {
-      case 'up':
-        await runUp(migrator, args.slice(1));
-        break;
-      case 'down':
-        await runDown(migrator, args.slice(1));
-        break;
-      case 'status':
-        await runStatus(migrator);
-        break;
-      case 'generate':
-      case 'create':
-        await runGenerate(migrator, args.slice(1));
-        break;
-      case 'generate:entities':
-      case 'generate-entities':
-        await runGenerateFromEntities(migrator, args.slice(1));
-        break;
-      case 'sync':
-        await runSync(migrator, args.slice(1));
-        break;
-      case 'pending':
-        await runPending(migrator);
-        break;
-      default:
-        console.error(`Unknown command: ${command}`);
-        printHelp();
-        process.exit(1);
-    }
-
-    // Close the connection pool
-    const pool = config.querierPool as { end?: () => Promise<void> };
-    if (pool.end) {
-      await pool.end();
-    }
-  } catch (error) {
-    console.error('Error:', (error as Error).message);
-    process.exit(1);
-  }
-}
-
-async function runUp(migrator: Migrator, args: string[]) {
-  const options: { to?: string; step?: number } = {};
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--to' && args[i + 1]) {
-      options.to = args[++i];
-    } else if (args[i] === '--step' && args[i + 1]) {
-      options.step = Number.parseInt(args[++i], 10);
-    }
-  }
-
-  const results = await migrator.up(options);
-
-  if (results.length === 0) {
-    console.log('No pending migrations.');
-    return;
-  }
-
-  const successful = results.filter((r: any) => r.success).length;
-  const failed = results.filter((r: any) => !r.success).length;
-
-  console.log(`\nMigrations complete: ${successful} successful, ${failed} failed`);
-
-  if (failed > 0) {
-    process.exit(1);
-  }
-}
-
-async function runDown(migrator: Migrator, args: string[]) {
-  const options: { to?: string; step?: number } = { step: 1 }; // Default to 1 step
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--to' && args[i + 1]) {
-      options.to = args[++i];
-      delete options.step;
-    } else if (args[i] === '--step' && args[i + 1]) {
-      options.step = Number.parseInt(args[++i], 10);
-    } else if (args[i] === '--all') {
-      delete options.step;
-    }
-  }
-
-  const results = await migrator.down(options);
-
-  if (results.length === 0) {
-    console.log('No migrations to rollback.');
-    return;
-  }
-
-  const successful = results.filter((r: any) => r.success).length;
-  const failed = results.filter((r: any) => !r.success).length;
-
-  console.log(`\nRollback complete: ${successful} successful, ${failed} failed`);
-
-  if (failed > 0) {
-    process.exit(1);
-  }
-}
-
-async function runStatus(migrator: Migrator) {
-  const status = await migrator.status();
-
-  console.log('\n=== Migration Status ===\n');
-
-  console.log('Executed migrations:');
-  if (status.executed.length === 0) {
-    console.log('  (none)');
-  } else {
-    for (const name of status.executed) {
-      console.log(`  ✓ ${name}`);
-    }
-  }
-
-  console.log('\nPending migrations:');
-  if (status.pending.length === 0) {
-    console.log('  (none)');
-  } else {
-    for (const name of status.pending) {
-      console.log(`  ○ ${name}`);
-    }
-  }
-
-  console.log('');
-}
-
-async function runPending(migrator: Migrator) {
-  const pending = await migrator.pending();
-
-  if (pending.length === 0) {
-    console.log('No pending migrations.');
-    return;
-  }
-
-  console.log('Pending migrations:');
-  for (const migration of pending) {
-    console.log(`  ○ ${migration.name}`);
-  }
-}
-
-async function runGenerate(migrator: Migrator, args: string[]) {
-  const name = args.join('_') || 'migration';
-  const filePath = await migrator.generate(name);
-  console.log(`\nCreated migration: ${filePath}`);
-}
-
-async function runGenerateFromEntities(migrator: Migrator, args: string[]) {
-  const name = args.join('_') || 'schema';
-  const filePath = await migrator.generateFromEntities(name);
-  console.log(`\nCreated migration from entities: ${filePath}`);
-}
-
-async function runSync(migrator: Migrator, args: string[]) {
-  const force = args.includes('--force');
-
-  if (force) {
-    console.log('\n⚠️  WARNING: This will drop and recreate all tables!');
-    console.log('   All data will be lost. This should only be used in development.\n');
-  }
-
-  await migrator.sync({ force });
-  console.log('\nSchema sync completed.');
-}
-
-function printHelp() {
-  console.log(`
-@uql/migrate - Database migration tool for uql ORM
-
-Usage: @uql/migrate <command> [options]
-
-Commands:
-  up                    Run all pending migrations
-    --to <name>         Run migrations up to and including <name>
-    --step <n>          Run only <n> migrations
-
-  down                  Rollback the last migration
-    --to <name>         Rollback to (and including) migration <name>
-    --step <n>          Rollback <n> migrations (default: 1)
-    --all               Rollback all migrations
-
-  status                Show migration status
-
-  pending               Show pending migrations
-
-  generate <name>       Create a new empty migration file
-  create <name>         Alias for generate
-
-  generate:entities     Generate migration from entity definitions
-    <name>              Optional name for the migration
-
-  sync                  Sync schema directly (development only!)
-    --force             Drop and recreate all tables
-
-Configuration:
-  Create a uql.config.ts or uql.config.js file in your project root:
-
-  export default {
-    querierPool: new PgQuerierPool({ ... }),
-    migrationsPath: './migrations',
-    tableName: 'uql_migrations',
-    dialect: 'postgres', // 'postgres' | 'mysql' | 'mariadb' | 'sqlite'
-    entities: [User, Post, ...],
-  };
-
-Examples:
-  @uql/migrate up
-  @uql/migrate up --step 1
-  @uql/migrate down
-  @uql/migrate down --step 3
-  @uql/migrate status
-  @uql/migrate generate add_users_table
-  @uql/migrate generate:entities initial_schema
-`);
-}
-
-main().catch(console.error);

package/src/migrate/generator/index.ts

@@ -1,4 +0,0 @@
-export * from './mongoSchemaGenerator.js';
-export { MysqlSchemaGenerator, MysqlSchemaGenerator as MariadbSchemaGenerator } from './mysqlSchemaGenerator.js';
-export * from './postgresSchemaGenerator.js';
-export * from './sqliteSchemaGenerator.js';