@uql/core 3.1.1 → 3.1.3

package/src/postgres/pgQuerierPool.test.ts

@@ -1,28 +0,0 @@
-import { types } from 'pg';
-import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
-import { createSpec } from '../test/index.js';
-import type { PgQuerier } from './pgQuerier.js';
-import { PgQuerierPool } from './pgQuerierPool.js';
-
-types.setTypeParser(types.builtins.INT8, (value: string) => Number.parseInt(value, 10));
-types.setTypeParser(types.builtins.FLOAT8, (value: string) => Number.parseFloat(value));
-types.setTypeParser(types.builtins.NUMERIC, (value: string) => Number.parseFloat(value));
-types.setTypeParser(types.builtins.INT8, (value: string) => Number.parseInt(value, 10));
-types.setTypeParser(types.builtins.FLOAT8, (value: string) => Number.parseFloat(value));
-types.setTypeParser(types.builtins.NUMERIC, (value: string) => Number.parseFloat(value));
-
-export class PostgresQuerierPoolIt extends AbstractQuerierPoolIt<PgQuerier> {
-  constructor() {
-    super(
-      new PgQuerierPool({
-        host: '0.0.0.0',
-        port: 5442,
-        user: 'test',
-        password: 'test',
-        database: 'test',
-      }),
-    );
-  }
-}
-
-createSpec(new PostgresQuerierPoolIt());

package/src/postgres/pgQuerierPool.ts

@@ -1,21 +0,0 @@
-import pg from 'pg';
-import { AbstractQuerierPool } from '../querier/index.js';
-import type { ExtraOptions } from '../type/index.js';
-import { PgQuerier } from './pgQuerier.js';
-
-export class PgQuerierPool extends AbstractQuerierPool<PgQuerier> {
-  readonly pool: pg.Pool;
-
-  constructor(opts: pg.PoolConfig, extra?: ExtraOptions) {
-    super('postgres', extra);
-    this.pool = new pg.Pool(opts);
-  }
-
-  async getQuerier() {
-    return new PgQuerier(() => this.pool.connect(), this.extra);
-  }
-
-  async end() {
-    await this.pool.end();
-  }
-}

package/src/postgres/postgresDialect.spec.ts

@@ -1,428 +0,0 @@
-import { expect } from 'bun:test';
-import {
-  Company,
-  createSpec,
-  Item,
-  ItemTag,
-  Profile,
-  TaxCategory,
-  User,
-  UserWithNonUpdatableId,
-} from '../test/index.js';
-import { raw } from '../util/index.js';
-import { PostgresDialect } from './postgresDialect.js';
-
-class PostgresDialectSpec {
-  readonly dialect = new PostgresDialect();
-
-  protected exec(fn: (ctx: any) => void): { sql: string; values: unknown[] } {
-    const ctx = this.dialect.createContext();
-    fn(ctx);
-    return { sql: ctx.sql, values: ctx.values };
-  }
-
-  shouldBeValidEscapeCharacter() {
-    expect(this.dialect.escapeIdChar).toBe('"');
-  }
-
-  shouldBeginTransaction() {
-    expect(this.dialect.beginTransactionCommand).toBe('BEGIN TRANSACTION');
-  }
-
-  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' +
-        ' ($1, $2, $3), ($4, $5, $6), ($7, $8, $9)' +
-        ' 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,
-    ]);
-  }
-
-  shouldInsertOne() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.insert(ctx, User, {
-        name: 'Some Name',
-        email: 'someemail@example.com',
-        createdAt: 123,
-      }),
-    );
-    expect(sql).toBe('INSERT INTO "User" ("name", "email", "createdAt") VALUES ($1, $2, $3) RETURNING "id" "id"');
-    expect(values).toEqual(['Some Name', 'someemail@example.com', 123]);
-  }
-
-  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 \(\$1, \$2, \$3\) RETURNING "pk" "id"$/,
-    );
-    expect(values[0]).toBe('Some Name');
-    expect(values[1]).toBe(123);
-    expect(values[2]).toMatch(/.+/);
-  }
-
-  shouldUpsert() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        User,
-        { id: true },
-        {
-          id: 1,
-          name: 'Some Name',
-          createdAt: 123,
-        },
-      ),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO "User" \("id", "name", "createdAt", "updatedAt"\) VALUES \(\$1, \$2, \$3, \$4\) ON CONFLICT \("id"\) DO UPDATE SET "name" = EXCLUDED."name", "createdAt" = EXCLUDED."createdAt", "updatedAt" = EXCLUDED."updatedAt" RETURNING "id" "id"$/,
-    );
-    expect(values).toEqual([1, 'Some Name', 123, expect.any(Number)]);
-  }
-
-  shouldUpsertWithDifferentColumnNames() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        Profile,
-        { pk: true },
-        {
-          pk: 1,
-          picture: 'image.jpg',
-        },
-      ),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO "user_profile" \("pk", "image", "updatedAt", "createdAt"\) VALUES \(\$1, \$2, \$3, \$4\) ON CONFLICT \("pk"\) DO UPDATE SET "image" = EXCLUDED."image", "updatedAt" = EXCLUDED."updatedAt" RETURNING "pk" "id"$/,
-    );
-    expect(values).toEqual([1, 'image.jpg', expect.any(Number), expect.any(Number)]);
-  }
-
-  shouldUpsertWithNonUpdatableFields() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        User,
-        { id: true },
-        {
-          id: 1,
-          email: 'a@b.com',
-        },
-      ),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO "User" \("id", "email", "updatedAt", "createdAt"\) VALUES \(\$1, \$2, \$3, \$4\) ON CONFLICT \("id"\) DO UPDATE SET "updatedAt" = EXCLUDED."updatedAt" RETURNING "id" "id"$/,
-    );
-    expect(values).toEqual([1, 'a@b.com', expect.any(Number), expect.any(Number)]);
-  }
-
-  shouldUpsertWithNonUpdatableId() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        UserWithNonUpdatableId,
-        { id: true },
-        {
-          id: 1,
-          name: 'Some Name',
-        },
-      ),
-    );
-    expect(sql).toBe(
-      'INSERT INTO "UserWithNonUpdatableId" ("id", "name") VALUES ($1, $2) ON CONFLICT ("id") DO UPDATE SET "name" = EXCLUDED."name" RETURNING "id" "id"',
-    );
-    expect(values).toEqual([1, 'Some Name']);
-  }
-
-  shouldUpsertWithDoNothing() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        ItemTag,
-        { id: true },
-        {
-          id: 1,
-        },
-      ),
-    );
-    expect(sql).toBe('INSERT INTO "ItemTag" ("id") VALUES ($1) ON CONFLICT ("id") DO NOTHING RETURNING "id" "id"');
-    expect(values).toEqual([1]);
-  }
-
-  shouldUpsertWithCompositeKeys() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        ItemTag,
-        { itemId: true, tagId: true },
-        {
-          itemId: 1,
-          tagId: 2,
-        },
-      ),
-    );
-    expect(sql).toBe(
-      'INSERT INTO "ItemTag" ("itemId", "tagId") VALUES ($1, $2) ON CONFLICT ("itemId", "tagId") DO NOTHING RETURNING "id" "id"',
-    );
-    expect(values).toEqual([1, 2]);
-  }
-
-  shouldUpsertWithOnUpdateField() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        User,
-        { id: true },
-        {
-          id: 1,
-          name: 'Some Name',
-        },
-      ),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO "User" \(.*"id".*"name".*"updatedAt".*"createdAt".*\) VALUES \(.*\$1, \$2, \$3, \$4.*\) ON CONFLICT \("id"\) DO UPDATE SET .*"name" = EXCLUDED."name".*"updatedAt" = EXCLUDED."updatedAt".*$/,
-    );
-    expect(values).toEqual([1, 'Some Name', expect.any(Number), expect.any(Number)]);
-  }
-
-  shouldUpsertWithVirtualField() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.upsert(
-        ctx,
-        Item,
-        { id: true },
-        {
-          id: 1,
-          name: 'Some Item',
-          tagsCount: 5,
-        },
-      ),
-    );
-    expect(sql).toMatch(
-      /^INSERT INTO "Item" \("id", "name", "updatedAt", "createdAt"\) VALUES \(\$1, \$2, \$3, \$4\) ON CONFLICT \("id"\) DO UPDATE SET "name" = EXCLUDED."name", "updatedAt" = EXCLUDED."updatedAt" RETURNING "id" "id"$/,
-    );
-    expect(values).toEqual([1, 'Some Item', expect.any(Number), expect.any(Number)]);
-  }
-
-  shouldFind$istartsWith() {
-    let res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: ['id'],
-        $where: { name: { $istartsWith: 'Some' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe('SELECT "id" FROM "User" WHERE "name" ILIKE $1 ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0');
-    expect(res.values).toEqual(['Some%']);
-
-    res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: { id: true },
-        $where: { name: { $istartsWith: 'Some', $ne: 'Something' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe(
-      'SELECT "id" FROM "User" WHERE ("name" ILIKE $1 AND "name" <> $2) ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0',
-    );
-    expect(res.values).toEqual(['Some%', 'Something']);
-  }
-
-  shouldFind$iendsWith() {
-    let res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: ['id'],
-        $where: { name: { $iendsWith: 'Some' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe('SELECT "id" FROM "User" WHERE "name" ILIKE $1 ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0');
-    expect(res.values).toEqual(['%Some']);
-
-    res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: { id: true },
-        $where: { name: { $iendsWith: 'Some', $ne: 'Something' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe(
-      'SELECT "id" FROM "User" WHERE ("name" ILIKE $1 AND "name" <> $2) ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0',
-    );
-    expect(res.values).toEqual(['%Some', 'Something']);
-  }
-
-  shouldFind$iincludes() {
-    let res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: ['id'],
-        $where: { name: { $iincludes: 'Some' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe('SELECT "id" FROM "User" WHERE "name" ILIKE $1 ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0');
-    expect(res.values).toEqual(['%Some%']);
-
-    res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: { id: true },
-        $where: { name: { $iincludes: 'Some', $ne: 'Something' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe(
-      'SELECT "id" FROM "User" WHERE ("name" ILIKE $1 AND "name" <> $2) ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0',
-    );
-    expect(res.values).toEqual(['%Some%', 'Something']);
-  }
-
-  shouldFind$ilike() {
-    let res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: ['id'],
-        $where: { name: { $ilike: 'Some' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe('SELECT "id" FROM "User" WHERE "name" ILIKE $1 ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0');
-    expect(res.values).toEqual(['Some']);
-
-    res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: { id: true },
-        $where: { name: { $ilike: 'Some', $ne: 'Something' } },
-        $sort: { name: 1, id: -1 },
-        $skip: 0,
-        $limit: 50,
-      }),
-    );
-    expect(res.sql).toBe(
-      'SELECT "id" FROM "User" WHERE ("name" ILIKE $1 AND "name" <> $2) ORDER BY "name", "id" DESC LIMIT 50 OFFSET 0',
-    );
-    expect(res.values).toEqual(['Some', 'Something']);
-  }
-
-  shouldFind$regex() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: { id: true },
-        $where: { name: { $regex: '^some' } },
-      }),
-    );
-    expect(sql).toBe('SELECT "id" FROM "User" WHERE "name" ~ $1');
-    expect(values).toEqual(['^some']);
-  }
-
-  shouldFind$text() {
-    let res = this.exec((ctx) =>
-      this.dialect.find(ctx, Item, {
-        $select: { id: true },
-        $where: { $text: { $fields: ['name', 'description'], $value: 'some text' }, code: '1' },
-        $limit: 30,
-      }),
-    );
-    expect(res.sql).toBe(
-      'SELECT "id" FROM "Item" WHERE to_tsvector("name" || \' \' || "description") @@ to_tsquery($1) AND "code" = $2 LIMIT 30',
-    );
-    expect(res.values).toEqual(['some text', '1']);
-
-    res = this.exec((ctx) =>
-      this.dialect.find(ctx, User, {
-        $select: { id: true },
-        $where: {
-          $text: { $fields: ['name'], $value: 'something' },
-          name: { $ne: 'other unwanted' },
-          creatorId: 1,
-        },
-        $limit: 10,
-      }),
-    );
-    expect(res.sql).toBe(
-      'SELECT "id" FROM "User" WHERE to_tsvector("name") @@ to_tsquery($1) AND "name" <> $2 AND "creatorId" = $3 LIMIT 10',
-    );
-    expect(res.values).toEqual(['something', 'other unwanted', 1]);
-  }
-
-  shouldUpdateWithRawString() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.update(
-        ctx,
-        Company,
-        { $where: { id: 1 } },
-        {
-          kind: raw("jsonb_set(kind, '{open}', to_jsonb(1))"),
-          updatedAt: 123,
-        },
-      ),
-    );
-    expect(sql).toBe(
-      'UPDATE "Company" SET "kind" = jsonb_set(kind, \'{open}\', to_jsonb(1)), "updatedAt" = $1 WHERE "id" = $2',
-    );
-    expect(values).toEqual([123, 1]);
-  }
-
-  shouldUpdateWithJsonbField() {
-    const { sql, values } = this.exec((ctx) =>
-      this.dialect.update(
-        ctx,
-        Company,
-        { $where: { id: 1 } },
-        {
-          kind: { private: 1 },
-          updatedAt: 123,
-        },
-      ),
-    );
-    expect(sql).toBe('UPDATE "Company" SET "kind" = $1::jsonb, "updatedAt" = $2 WHERE "id" = $3');
-    expect(values).toEqual(['{"private":1}', 123, 1]);
-  }
-}
-
-createSpec(new PostgresDialectSpec());

package/src/postgres/postgresDialect.ts

@@ -1,144 +0,0 @@
-import sqlstring from 'sqlstring-sqlite';
-import { AbstractSqlDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import {
-  type FieldKey,
-  type FieldOptions,
-  type NamingStrategy,
-  type QueryComparisonOptions,
-  type QueryConflictPaths,
-  type QueryContext,
-  type QueryOptions,
-  QueryRaw,
-  type QueryTextSearchOptions,
-  type QueryWhereFieldOperatorMap,
-  type QueryWhereMap,
-  type Type,
-} from '../type/index.js';
-
-export class PostgresDialect extends AbstractSqlDialect {
-  constructor(namingStrategy?: NamingStrategy) {
-    super(namingStrategy, '"', 'BEGIN TRANSACTION');
-  }
-
-  override addValue(values: unknown[], value: unknown): string {
-    values.push(value);
-    return this.placeholder(values.length);
-  }
-
-  override placeholder(index: number): string {
-    return `$${index}`;
-  }
-
-  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) => `EXCLUDED.${name}`);
-    const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);
-    const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
-    super.insert(ctx, entity, payload);
-    ctx.append(` ON CONFLICT (${keysStr}) ${onConflict} ${this.returningId(entity)}`);
-  }
-
-  override compare<E, K extends keyof QueryWhereMap<E>>(
-    ctx: QueryContext,
-    entity: Type<E>,
-    key: K,
-    val: QueryWhereMap<E>[K],
-    opts: QueryComparisonOptions = {},
-  ): void {
-    if (key === '$text') {
-      const meta = getMeta(entity);
-      const search = val as QueryTextSearchOptions<E>;
-      const fields = search.$fields
-        .map((fKey) => {
-          const field = meta.fields[fKey];
-          const columnName = this.resolveColumnName(fKey as string, field);
-          return this.escapeId(columnName);
-        })
-        .join(` || ' ' || `);
-      ctx.append(`to_tsvector(${fields}) @@ to_tsquery(`);
-      ctx.addValue(search.$value);
-      ctx.append(')');
-      return;
-    }
-    super.compare(ctx, entity, key, val, opts);
-  }
-
-  override compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(
-    ctx: QueryContext,
-    entity: Type<E>,
-    key: FieldKey<E>,
-    op: K,
-    val: QueryWhereFieldOperatorMap<E>[K],
-    opts: QueryOptions = {},
-  ): void {
-    switch (op) {
-      case '$istartsWith':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' ILIKE ');
-        ctx.addValue(`${val}%`);
-        break;
-      case '$iendsWith':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' ILIKE ');
-        ctx.addValue(`%${val}`);
-        break;
-      case '$iincludes':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' ILIKE ');
-        ctx.addValue(`%${val}%`);
-        break;
-      case '$ilike':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' ILIKE ');
-        ctx.addValue(val);
-        break;
-      case '$in':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' = ANY(');
-        ctx.addValue(val);
-        ctx.append(')');
-        break;
-      case '$nin':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' <> ALL(');
-        ctx.addValue(val);
-        ctx.append(')');
-        break;
-      case '$regex':
-        this.getComparisonKey(ctx, entity, key, opts);
-        ctx.append(' ~ ');
-        ctx.addValue(val);
-        break;
-      default:
-        super.compareFieldOperator(ctx, entity, key, op, val, opts);
-    }
-  }
-
-  protected override formatPersistableValue<E>(ctx: QueryContext, field: FieldOptions, value: unknown): void {
-    if (value instanceof QueryRaw) {
-      super.formatPersistableValue(ctx, field, value);
-      return;
-    }
-    if (field.type === 'json' || field.type === 'jsonb') {
-      ctx.addValue(value ? JSON.stringify(value) : null);
-      ctx.append(`::${field.type}`);
-      return;
-    }
-    if (field.type === 'vector' && Array.isArray(value)) {
-      ctx.addValue(`[${value.join(',')}]`);
-      ctx.append('::vector');
-      return;
-    }
-    super.formatPersistableValue(ctx, field, value);
-  }
-
-  override escape(value: unknown): string {
-    return sqlstring.escape(value);
-  }
-}