@uql/core 1.0.12 → 3.1.0

package/src/postgres/pgQuerierPool.test.ts

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,428 @@
+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

@@ -0,0 +1,144 @@
+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);
+  }
+}