@uql/core 1.0.12 → 3.1.0

package/dist/options.js

@@ -0,0 +1,14 @@
+let defaultPool;
+export function setQuerierPool(pool) {
+    defaultPool = pool;
+}
+export function getQuerierPool() {
+    if (!defaultPool) {
+        throw new TypeError('A default querier-pool has to be set first');
+    }
+    return defaultPool;
+}
+export function getQuerier() {
+    return defaultPool.getQuerier();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLElBQUksV0FBd0IsQ0FBQztBQUU3QixNQUFNLFVBQVUsY0FBYyxDQUFzQyxJQUFPO0lBQ3pFLFdBQVcsR0FBRyxJQUFJLENBQUM7QUFDckIsQ0FBQztBQUVELE1BQU0sVUFBVSxjQUFjO0lBQzVCLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqQixNQUFNLElBQUksU0FBUyxDQUFDLDRDQUE0QyxDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUNELE9BQU8sV0FBVyxDQUFDO0FBQ3JCLENBQUM7QUFFRCxNQUFNLFVBQVUsVUFBVTtJQUN4QixPQUFPLFdBQVcsQ0FBQyxVQUFVLEVBQUUsQ0FBQztBQUNsQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBRdWVyaWVyLCBRdWVyaWVyUG9vbCB9IGZyb20gJy4vdHlwZS9pbmRleC5qcyc7XG5cbmxldCBkZWZhdWx0UG9vbDogUXVlcmllclBvb2w7XG5cbmV4cG9ydCBmdW5jdGlvbiBzZXRRdWVyaWVyUG9vbDxUIGV4dGVuZHMgUXVlcmllclBvb2wgPSBRdWVyaWVyUG9vbD4ocG9vbDogVCk6IHZvaWQge1xuICBkZWZhdWx0UG9vbCA9IHBvb2w7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRRdWVyaWVyUG9vbCgpOiBRdWVyaWVyUG9vbCB7XG4gIGlmICghZGVmYXVsdFBvb2wpIHtcbiAgICB0aHJvdyBuZXcgVHlwZUVycm9yKCdBIGRlZmF1bHQgcXVlcmllci1wb29sIGhhcyB0byBiZSBzZXQgZmlyc3QnKTtcbiAgfVxuICByZXR1cm4gZGVmYXVsdFBvb2w7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRRdWVyaWVyKCk6IFByb21pc2U8UXVlcmllcj4ge1xuICByZXR1cm4gZGVmYXVsdFBvb2wuZ2V0UXVlcmllcigpO1xufVxuIl19

package/dist/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@uql/core",
+  "homepage": "https://uql.app",
+  "description": "One Language. Frontend to Backend.",
+  "license": "MIT",
+  "version": "3.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "bin": {
+    "uql-migrate": "./migrate/cli.js"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./dialect": "./dialect/index.js",
+    "./entity": "./entity/index.js",
+    "./querier": "./querier/index.js",
+    "./repository": "./repository/index.js",
+    "./type": "./type/index.js",
+    "./util": "./util/index.js",
+    "./namingStrategy": "./namingStrategy/index.js",
+    "./migrate": "./migrate/index.js",
+    "./options": "./options.js",
+    "./test": "./test/index.js",
+    "./mysql": "./mysql/index.js",
+    "./postgres": "./postgres/index.js",
+    "./maria": "./maria/index.js",
+    "./sqlite": "./sqlite/index.js",
+    "./mongo": "./mongo/index.js",
+    "./express": "./express/index.js",
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "import": "./browser/index.js",
+      "default": "./browser/uql-browser.min.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "copyfiles": "copyfiles -f package.json ../README.md ../CHANGELOG.md dist",
+    "compile.browser": "bunchee --clean false --no-dts ./src/browser/index.ts --sourcemap -o ./dist/browser/uql-browser.min.js",
+    "build": "bun run clean && tsc -b tsconfig.build.json && bun run compile.browser && bun run copyfiles",
+    "start": "tsc --watch",
+    "clean": "rimraf dist *.tsbuildinfo"
+  },
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "sqlstring": "^2.3.3",
+    "sqlstring-sqlite": "^0.1.1",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "better-sqlite3": ">=9.0.0",
+    "express": ">=5.0.0",
+    "mariadb": ">=3.0.0",
+    "mongodb": ">=6.0.0",
+    "mysql2": ">=3.0.0",
+    "pg": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "mariadb": {
+      "optional": true
+    },
+    "mongodb": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.0.3",
+    "@types/pg": "^8.16.0",
+    "@types/sqlstring": "^2.3.2",
+    "better-sqlite3": "^12.5.0",
+    "bunchee": "^6.9.1",
+    "copyfiles": "^2.4.1",
+    "express": "^5.2.1",
+    "mariadb": "^3.4.5",
+    "mongodb": "^7.0.0",
+    "mysql2": "^3.16.0",
+    "pg": "^8.16.3",
+    "rimraf": "^6.1.2",
+    "typescript": "~5.4.5"
+  },
+  "author": "Roger Padilla",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rogerpadilla/uql.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rogerpadilla/uql/issues"
+  },
+  "keywords": [
+    "orm",
+    "data-mapper",
+    "persistence",
+    "typescript-orm",
+    "javascript-orm",
+    "mariadb",
+    "mariadb-orm",
+    "mysql",
+    "mysql-orm",
+    "postgresql",
+    "postgresql-orm",
+    "sqlite",
+    "sqlite-orm",
+    "mongodb",
+    "mongodb-orm",
+    "entity",
+    "dao",
+    "transaction",
+    "repository",
+    "service",
+    "migrations"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e866a829b6d8c55457c2708e53aa758c08280a37"
+}

package/dist/postgres/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pgQuerier.js';
+export * from './pgQuerierPool.js';
+export * from './postgresDialect.js';

package/dist/postgres/index.js

@@ -0,0 +1,4 @@
+export * from './pgQuerier.js';
+export * from './pgQuerierPool.js';
+export * from './postgresDialect.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcG9zdGdyZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BnUXVlcmllci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BnUXVlcmllclBvb2wuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9wb3N0Z3Jlc0RpYWxlY3QuanMnO1xuIl19

package/dist/postgres/pgQuerier.d.ts

@@ -0,0 +1,17 @@
+import type { PoolClient } from 'pg';
+import { AbstractSqlQuerier } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+export declare class PgQuerier extends AbstractSqlQuerier {
+    readonly connect: () => Promise<PoolClient>;
+    readonly extra?: ExtraOptions;
+    conn: PoolClient;
+    constructor(connect: () => Promise<PoolClient>, extra?: ExtraOptions);
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalRun(query: string, values?: unknown[]): Promise<{
+        changes: any;
+        ids: any;
+        firstId: any;
+    }>;
+    lazyConnect(): Promise<void>;
+    internalRelease(): Promise<void>;
+}

package/dist/postgres/pgQuerier.js

@@ -0,0 +1,39 @@
+import { AbstractSqlQuerier } from '../querier/index.js';
+import { PostgresDialect } from './postgresDialect.js';
+export class PgQuerier extends AbstractSqlQuerier {
+    connect;
+    extra;
+    conn;
+    constructor(connect, extra) {
+        super(new PostgresDialect(extra?.namingStrategy));
+        this.connect = connect;
+        this.extra = extra;
+    }
+    async internalAll(query, values) {
+        this.extra?.logger?.(query, values);
+        await this.lazyConnect();
+        const res = await this.conn.query(query, values);
+        return res.rows;
+    }
+    async internalRun(query, values) {
+        this.extra?.logger?.(query, values);
+        await this.lazyConnect();
+        const { rowCount: changes, rows = [] } = await this.conn.query(query, values);
+        const ids = rows.map((r) => r.id);
+        return { changes, ids, firstId: ids[0] };
+    }
+    async lazyConnect() {
+        this.conn ??= await this.connect();
+    }
+    async internalRelease() {
+        if (this.hasOpenTransaction) {
+            throw TypeError('pending transaction');
+        }
+        if (!this.conn) {
+            return;
+        }
+        await this.conn.release();
+        this.conn = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/postgres/pgQuerier.test.d.ts

@@ -0,0 +1,4 @@
+import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
+export declare class PostgresQuerierIt extends AbstractSqlQuerierIt {
+    constructor();
+}

package/dist/postgres/pgQuerier.test.js

@@ -0,0 +1,20 @@
+import { types } from 'pg';
+import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
+import { createSpec } from '../test/index.js';
+import { PgQuerierPool } from './pgQuerierPool.js';
+types.setTypeParser(types.builtins.INT8, (value) => Number.parseInt(value, 10));
+types.setTypeParser(types.builtins.FLOAT8, (value) => Number.parseFloat(value));
+types.setTypeParser(types.builtins.NUMERIC, (value) => Number.parseFloat(value));
+export class PostgresQuerierIt extends AbstractSqlQuerierIt {
+    constructor() {
+        super(new PgQuerierPool({
+            host: '0.0.0.0',
+            port: 5442,
+            user: 'test',
+            password: 'test',
+            database: 'test',
+        }), 'SERIAL PRIMARY KEY');
+    }
+}
+createSpec(new PostgresQuerierIt());
+//# sourceMappingURL=data:application/json;base64,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

package/dist/postgres/pgQuerierPool.d.ts

@@ -0,0 +1,10 @@
+import pg from 'pg';
+import { AbstractQuerierPool } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import { PgQuerier } from './pgQuerier.js';
+export declare class PgQuerierPool extends AbstractQuerierPool<PgQuerier> {
+    readonly pool: pg.Pool;
+    constructor(opts: pg.PoolConfig, extra?: ExtraOptions);
+    getQuerier(): Promise<PgQuerier>;
+    end(): Promise<void>;
+}

package/dist/postgres/pgQuerierPool.js

@@ -0,0 +1,17 @@
+import pg from 'pg';
+import { AbstractQuerierPool } from '../querier/index.js';
+import { PgQuerier } from './pgQuerier.js';
+export class PgQuerierPool extends AbstractQuerierPool {
+    pool;
+    constructor(opts, extra) {
+        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();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGdRdWVyaWVyUG9vbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wb3N0Z3Jlcy9wZ1F1ZXJpZXJQb29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQztBQUNwQixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUUxRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFM0MsTUFBTSxPQUFPLGFBQWMsU0FBUSxtQkFBOEI7SUFDdEQsSUFBSSxDQUFVO0lBRXZCLFlBQVksSUFBbUIsRUFBRSxLQUFvQjtRQUNuRCxLQUFLLENBQUMsVUFBVSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRCxLQUFLLENBQUMsVUFBVTtRQUNkLE9BQU8sSUFBSSxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVELEtBQUssQ0FBQyxHQUFHO1FBQ1AsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQ3hCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBwZyBmcm9tICdwZyc7XG5pbXBvcnQgeyBBYnN0cmFjdFF1ZXJpZXJQb29sIH0gZnJvbSAnLi4vcXVlcmllci9pbmRleC5qcyc7XG5pbXBvcnQgdHlwZSB7IEV4dHJhT3B0aW9ucyB9IGZyb20gJy4uL3R5cGUvaW5kZXguanMnO1xuaW1wb3J0IHsgUGdRdWVyaWVyIH0gZnJvbSAnLi9wZ1F1ZXJpZXIuanMnO1xuXG5leHBvcnQgY2xhc3MgUGdRdWVyaWVyUG9vbCBleHRlbmRzIEFic3RyYWN0UXVlcmllclBvb2w8UGdRdWVyaWVyPiB7XG4gIHJlYWRvbmx5IHBvb2w6IHBnLlBvb2w7XG5cbiAgY29uc3RydWN0b3Iob3B0czogcGcuUG9vbENvbmZpZywgZXh0cmE/OiBFeHRyYU9wdGlvbnMpIHtcbiAgICBzdXBlcigncG9zdGdyZXMnLCBleHRyYSk7XG4gICAgdGhpcy5wb29sID0gbmV3IHBnLlBvb2wob3B0cyk7XG4gIH1cblxuICBhc3luYyBnZXRRdWVyaWVyKCkge1xuICAgIHJldHVybiBuZXcgUGdRdWVyaWVyKCgpID0+IHRoaXMucG9vbC5jb25uZWN0KCksIHRoaXMuZXh0cmEpO1xuICB9XG5cbiAgYXN5bmMgZW5kKCkge1xuICAgIGF3YWl0IHRoaXMucG9vbC5lbmQoKTtcbiAgfVxufVxuIl19

package/dist/postgres/pgQuerierPool.test.d.ts

@@ -0,0 +1,5 @@
+import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
+import type { PgQuerier } from './pgQuerier.js';
+export declare class PostgresQuerierPoolIt extends AbstractQuerierPoolIt<PgQuerier> {
+    constructor();
+}

package/dist/postgres/pgQuerierPool.test.js

@@ -0,0 +1,23 @@
+import { types } from 'pg';
+import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
+import { createSpec } from '../test/index.js';
+import { PgQuerierPool } from './pgQuerierPool.js';
+types.setTypeParser(types.builtins.INT8, (value) => Number.parseInt(value, 10));
+types.setTypeParser(types.builtins.FLOAT8, (value) => Number.parseFloat(value));
+types.setTypeParser(types.builtins.NUMERIC, (value) => Number.parseFloat(value));
+types.setTypeParser(types.builtins.INT8, (value) => Number.parseInt(value, 10));
+types.setTypeParser(types.builtins.FLOAT8, (value) => Number.parseFloat(value));
+types.setTypeParser(types.builtins.NUMERIC, (value) => Number.parseFloat(value));
+export class PostgresQuerierPoolIt extends AbstractQuerierPoolIt {
+    constructor() {
+        super(new PgQuerierPool({
+            host: '0.0.0.0',
+            port: 5442,
+            user: 'test',
+            password: 'test',
+            database: 'test',
+        }));
+    }
+}
+createSpec(new PostgresQuerierPoolIt());
+//# sourceMappingURL=data:application/json;base64,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

package/dist/postgres/postgresDialect.d.ts

@@ -0,0 +1,13 @@
+import { AbstractSqlDialect } from '../dialect/index.js';
+import { type FieldKey, type FieldOptions, type NamingStrategy, type QueryComparisonOptions, type QueryConflictPaths, type QueryContext, type QueryOptions, type QueryWhereFieldOperatorMap, type QueryWhereMap, type Type } from '../type/index.js';
+export declare class PostgresDialect extends AbstractSqlDialect {
+    constructor(namingStrategy?: NamingStrategy);
+    addValue(values: unknown[], value: unknown): string;
+    placeholder(index: number): string;
+    insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
+    upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void;
+    compare<E, K extends keyof QueryWhereMap<E>>(ctx: QueryContext, entity: Type<E>, key: K, val: QueryWhereMap<E>[K], opts?: QueryComparisonOptions): void;
+    compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(ctx: QueryContext, entity: Type<E>, key: FieldKey<E>, op: K, val: QueryWhereFieldOperatorMap<E>[K], opts?: QueryOptions): void;
+    protected formatPersistableValue<E>(ctx: QueryContext, field: FieldOptions, value: unknown): void;
+    escape(value: unknown): string;
+}

package/dist/postgres/postgresDialect.js

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

package/dist/querier/abstractQuerier-test.d.ts

@@ -0,0 +1,45 @@
+import { type Spec } from '../test/index.js';
+import type { Querier, QuerierPool } from '../type/index.js';
+export declare abstract class AbstractQuerierIt<Q extends Querier> implements Spec {
+    protected pool: QuerierPool<Q>;
+    querier: Q;
+    constructor(pool: QuerierPool<Q>);
+    beforeAll(): Promise<void>;
+    beforeEach(): Promise<void>;
+    afterEach(): Promise<void>;
+    afterAll(): Promise<void>;
+    shouldGetRepository(): void;
+    shouldInsertMany(): Promise<void>;
+    shouldInsertManyEmpty(): Promise<void>;
+    shouldInsertOne(): Promise<void>;
+    shouldInsertOneWithOnInsertId(): Promise<void>;
+    shouldInsertManyWithSpecifiedIdsAndOnInsertIdAsDefault(): Promise<void>;
+    shouldInsertManyWithAutoIncrementIdAsDefault(): Promise<void>;
+    shouldInsertOneAndCascadeOneToOne(): Promise<void>;
+    shouldInsertOneAndCascadeManyToOne(): Promise<void>;
+    shouldInsertSpecialChars(): Promise<void>;
+    shouldInsertOneAndCascadeOneToMany(): Promise<void>;
+    shouldInsertOneAndCascadeOneToManyWithSpecificFields(): Promise<void>;
+    shouldUpdateOneAndCascadeOneToMany(): Promise<void>;
+    shouldUpdateOneByIdAndCascadeOneToManyNull(): Promise<void>;
+    shouldUpdateManyAndCascadeOneToManyNull(): Promise<void>;
+    shouldInsertOneAndCascadeManyToMany(): Promise<void>;
+    shouldUpdateOneAndCascadeManyToMany(): Promise<void>;
+    shouldUpsertOne(): Promise<void>;
+    shouldFindOne(): Promise<void>;
+    shouldCount(): Promise<void>;
+    shouldUpdateMany(): Promise<void>;
+    shouldThrowIfUnknownComparisonOperator(): Promise<void>;
+    shouldThrowWhenRollbackTransactionWithoutBeginTransaction(): Promise<void>;
+    shouldCommit(): Promise<void>;
+    shouldRollback(): Promise<void>;
+    shouldThrowWhenBeginTransactionAfterBeginTransaction(): Promise<void>;
+    shouldReturnTransactionValue(): Promise<void>;
+    shouldThrowWhenCommitTransactionWithoutBeginTransaction(): Promise<void>;
+    shouldSelectOneToManyEmpty(): Promise<void>;
+    shouldSelectOneToMany(): Promise<void>;
+    shouldDeleteMany(): Promise<void>;
+    clearTables(): Promise<void>;
+    abstract createTables(): Promise<void>;
+    abstract dropTables(): Promise<void>;
+}