@art-ws/db-context 1.0.3-rc.4 → 2.0.1

package/dist/{db-client → es/db-client}/db-client.d.ts

@@ -1,6 +1,7 @@
-import { IDisposable } from "@art-ws/common";
-export declare type DbClientFactory<C> = () => Promise<DbClient<C>>;
+import type { IDisposable } from "@art-ws/common";
+export type DbClientFactory<C> = () => Promise<DbClient<C>>;
 export interface DbQueryArgs<P = unknown> {
+    name?: string;
     sql: string;
     params?: P;
 }
@@ -8,6 +9,7 @@ export interface DbQuery<T> extends PromiseLike<T[]> {
     single(): Promise<T>;
     first(): Promise<T>;
     last(): Promise<T>;
+    exec(): Promise<number>;
     asArray(): Promise<T[]>;
     asIterable(): Promise<Iterable<T>>;
     asAsyncIterable(): Promise<AsyncIterable<T>>;
@@ -19,5 +21,4 @@ export interface DbClient<C> extends IDisposable<void> {
 export interface DbQueryConstructorArgs<C, P = unknown> extends DbQueryArgs<P> {
     dbClientFactory: DbClientFactory<C>;
 }
-export declare type DbQueryFactory<C = unknown, T = DbQuery<unknown>> = (args: DbQueryConstructorArgs<C>) => T;
-//# sourceMappingURL=db-client.d.ts.map
+export type DbQueryFactory<C = unknown, T = DbQuery<unknown>> = (args: DbQueryConstructorArgs<C>) => T;

package/dist/es/db-client/db-client.js

@@ -0,0 +1 @@
+export {};

package/dist/{db-client → es/db-client}/db-query-base.d.ts

@@ -1,12 +1,13 @@
-import { DbQuery } from "./db-client";
+import type { DbQuery } from "./db-client";
 export declare abstract class DbQueryBase<T> implements DbQuery<T> {
     then<TResult1 = T[], TResult2 = never>(onfulfilled?: (value: T[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
+    abstract getName(): string;
     single(): Promise<T>;
     first(): Promise<T>;
     last(): Promise<T>;
     asIterable(): Promise<Iterable<T>>;
     asAsyncIterable(): Promise<AsyncIterable<T>>;
     abstract asArray(): Promise<T[]>;
+    abstract exec(): Promise<number>;
     abstract cancel(reason?: string | Error): Promise<void>;
 }
-//# sourceMappingURL=db-query-base.d.ts.map

package/dist/{db-client → es/db-client}/db-query-base.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbQueryBase = void 0;
-class DbQueryBase {
+export class DbQueryBase {
     then(onfulfilled, onrejected) {
         return this.asArray().then((rows) => {
-            onfulfilled ? onfulfilled(rows) : undefined;
+            return onfulfilled ? onfulfilled(rows) : undefined;
         }, (err) => {
-            onrejected ? onrejected(err) : undefined;
+            return onrejected ? onrejected(err) : undefined;
         });
     }
     async single() {
         const rows = await this.asArray();
         if (rows.length !== 1)
-            throw new Error(`Expected a single query result`);
+            throw new Error(`Expected a single query result (${this.getName()})`);
         return rows[0];
     }
     async first() {
@@ -30,5 +27,3 @@ class DbQueryBase {
         throw new Error("Method not implemented.");
     }
 }
-exports.DbQueryBase = DbQueryBase;
-//# sourceMappingURL=db-query-base.js.map

package/dist/{db-client → es/db-client}/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./db-client";
 export * from "./db-query-base";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/db-client/index.js

@@ -0,0 +1,3 @@
+// created from 'create-ts-index'
+export * from "./db-client";
+export * from "./db-query-base";

package/dist/{db-context → es/db-context}/db-context.d.ts

@@ -1,9 +1,9 @@
-import { DbClientFactory, DbQuery, DbQueryFactory, DbQueryArgs } from "../db-client";
-import { DbContext } from "./types";
-import { IDisposable } from "@art-ws/common";
+import type { IDisposable } from "@art-ws/common";
+import type { DbClientFactory, DbQuery, DbQueryArgs, DbQueryFactory } from "../db-client";
+import type { DbContext } from "./types";
 export declare class DbContextBase<S> implements DbContext.Context, IDisposable<void> {
     private dbQueryFactory;
-    private dbClient;
+    private dbClient?;
     readonly getDbClient: DbClientFactory<unknown>;
     private factories;
     private refs;
@@ -11,7 +11,8 @@ export declare class DbContextBase<S> implements DbContext.Context, IDisposable<
     getDbModel<T>(name: string): T;
     protected add(name: keyof S, fn: Function): void;
     protected get<T>(name: keyof S): T;
+    query<T>(sql: string, params?: unknown[]): DbQuery<T>;
+    select<T>(sql: string, params?: unknown[]): DbQuery<T>;
     getDbQuery<T>(args: DbQueryArgs<unknown>): DbQuery<T>;
     dispose(): void;
 }
-//# sourceMappingURL=db-context.d.ts.map

package/dist/{db-context → es/db-context}/db-context.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbContextBase = void 0;
-const common_1 = require("@art-ws/common");
-class DbContextBase {
+import { synchronized } from "@art-ws/common";
+export class DbContextBase {
+    dbQueryFactory;
+    dbClient;
+    getDbClient;
+    factories = new Map();
+    refs = new Map();
     constructor(dbClientFactory, dbQueryFactory) {
         this.dbQueryFactory = dbQueryFactory;
-        this.factories = new Map();
-        this.refs = new Map();
-        this.getDbClient = () => common_1.racePromise("getDbClient", async () => {
+        this.getDbClient = () => synchronized("getDbClient", async () => {
             if (!this.dbClient) {
                 this.dbClient = await dbClientFactory();
             }
@@ -23,10 +23,21 @@ class DbContextBase {
     get(name) {
         let ref = this.refs.get(name);
         if (!ref) {
-            ref = this.factories.get(name)();
+            const factory = this.factories.get(name);
+            if (factory) {
+                ref = factory();
+            }
         }
         return ref;
     }
+    query(sql, params) {
+        const name = sql.substring(0, 10);
+        return this.getDbQuery({ name, sql, params: params ?? [] });
+    }
+    select(sql, params) {
+        const name = sql.substring(0, 10);
+        return this.getDbQuery({ name, sql, params: params ?? [] });
+    }
     getDbQuery(args) {
         return this.dbQueryFactory({
             dbClientFactory: () => this.getDbClient(),
@@ -39,5 +50,3 @@ class DbContextBase {
         }
     }
 }
-exports.DbContextBase = DbContextBase;
-//# sourceMappingURL=db-context.js.map

package/dist/es/db-context/db-model.d.ts

@@ -0,0 +1,28 @@
+import type { DbContext } from "./types";
+export type GenericOfDbModel<T> = T extends DbModel<infer X> ? X : never;
+export declare class DbModel<T> implements DbContext.Model, DbContext.ModelApi<T> {
+    dbContext: DbContext.Context;
+    meta: DbContext.ModelInfo;
+    logger: import("@art-ws/slf").Logger;
+    primaryKeys: DbContext.Column[];
+    constructor(dbContext: DbContext.Context, meta: DbContext.ModelInfo);
+    getSeqDefaultName(): string;
+    nextDefaultSeqVal(): Promise<number>;
+    nextval(seq: string): Promise<number>;
+    findAll(options?: DbContext.SelectOptions<T>): DbContext.Query<T>;
+    findById(id: unknown): DbContext.Query<T>;
+    toSqlParams(sqlText: string, p?: object | unknown[]): {
+        sql: string;
+        params: unknown[];
+    };
+    where(sqlWhere: string, p?: object | unknown[]): DbContext.Query<T>;
+    select<D = T>(sqlText: string, p?: object | unknown[]): DbContext.Query<D>;
+    private withTableWhere;
+    findBy(values: Partial<T>, opts?: DbContext.SelectOptions<T>): DbContext.Query<T>;
+    insert(values: Partial<T>): DbContext.Query<T>;
+    upsert(values: Partial<T>, o: {
+        unique: (keyof T)[];
+    }): DbContext.Query<T>;
+    update(values: Partial<T>, where?: (keyof T)[] | Partial<T>): DbContext.Query<T>;
+    del(values: Partial<T>): DbContext.Query<T>;
+}

package/dist/es/db-context/db-model.js

@@ -0,0 +1,235 @@
+import { getLogger } from "@art-ws/slf";
+function toOrderBySQL(o) {
+    let s = "";
+    if (o?.orderBy) {
+        s = ` order by ${o?.orderBy}`;
+    }
+    return s;
+}
+function toPagingSQL(o, withDefaults) {
+    let s = "";
+    if (o === null)
+        return s;
+    if (!o) {
+        if (withDefaults) {
+            o = {
+                limit: -1,
+                offset: 0,
+            };
+        }
+        else {
+            return s;
+        }
+    }
+    if (o.limit && o.limit > -1)
+        s += ` limit ${o.limit}`;
+    if (o.offset && o.offset > 0)
+        s += ` offset ${o.offset}`;
+    return s;
+}
+export class DbModel {
+    dbContext;
+    meta;
+    logger = getLogger(DbModel);
+    primaryKeys = [];
+    constructor(dbContext, meta) {
+        this.dbContext = dbContext;
+        this.meta = meta;
+        this.primaryKeys = meta.columns.filter((col) => col.isPrimaryKey);
+    }
+    getSeqDefaultName() {
+        return `${this.meta.table}_seq`;
+    }
+    async nextDefaultSeqVal() {
+        return this.nextval(this.getSeqDefaultName());
+    }
+    async nextval(seq) {
+        const result = await this.dbContext
+            .getDbQuery({
+            name: `nextval(${seq}) on ${this.meta.table}`,
+            sql: `select nextval('${seq}') as id`,
+            params: [],
+        })
+            .single();
+        return result.id;
+    }
+    // https://stackoverflow.com/questions/3984643/equivalent-of-found-rows-function-in-postgresql/22353886#22353886
+    findAll(options) {
+        const sql = `SELECT * FROM ${this.meta.table} ${toOrderBySQL(options)} ${toPagingSQL(options, true)}`;
+        return this.dbContext.getDbQuery({
+            name: `findAll on ${this.meta.table}`,
+            sql,
+            params: [],
+        });
+    }
+    findById(id) {
+        if (this.primaryKeys?.length !== 1)
+            throw Error(`Table '${this.meta.table}' must have just a single primary key, instead of ${this.primaryKeys.length}`);
+        const pk = this.primaryKeys[0];
+        const sql = `SELECT * FROM ${this.meta.table} WHERE ${pk.name} = $1`;
+        return this.dbContext.getDbQuery({
+            name: `findById(${id}) on ${this.meta.table}`,
+            sql,
+            params: [id],
+        });
+    }
+    toSqlParams(sqlText, p) {
+        let params = [];
+        let sql = sqlText;
+        if (p) {
+            if (Array.isArray(p)) {
+                params = p;
+            }
+            else if (typeof p === "object") {
+                Object.keys(p).forEach((key, i) => {
+                    sql = sql.replace(`{${key}}`, `$${i + 1}`);
+                    params.push(p[key] ?? null);
+                });
+            }
+            else {
+                params = [p];
+            }
+        }
+        return {
+            sql,
+            params,
+        };
+    }
+    where(sqlWhere, p) {
+        const sql = `SELECT * FROM ${this.meta.table} WHERE ${sqlWhere}`;
+        return this.select(sql, p);
+    }
+    select(sqlText, p) {
+        const par = this.toSqlParams(sqlText, p);
+        return this.dbContext.getDbQuery({
+            name: `select(${sqlText.substring(10)}) on ${this.meta.table}`,
+            sql: par.sql,
+            params: par.params,
+        });
+    }
+    withTableWhere(expr, values, opts) {
+        const params = [];
+        const s = [];
+        let i = 0;
+        Object.keys(values).forEach((key) => {
+            const v = values[key] ?? null;
+            if (v === null) {
+                s.push(`( ${key} IS NULL )`);
+            }
+            else {
+                i++;
+                s.push(`( ${key} = $${i} )`);
+                params.push(v);
+            }
+        });
+        let where = `${s.join(" AND ")}`;
+        if (where) {
+            where = `WHERE ${where}`;
+        }
+        const sql = `${expr} FROM ${this.meta.table} ${where} ${toPagingSQL(opts, true)} ${toOrderBySQL(opts)}`;
+        return this.dbContext.getDbQuery({
+            name: `withTableWhere of ${this.meta.table}`,
+            sql,
+            params: params,
+        });
+    }
+    findBy(values, opts) {
+        return this.withTableWhere("SELECT *", values, opts);
+    }
+    insert(values) {
+        const params = [];
+        const cols = [];
+        const pValues = [];
+        Object.keys(values).forEach((key, i) => {
+            cols.push(key);
+            pValues.push(`$${i + 1}`);
+            params.push(values[key] ?? null);
+        });
+        const sql = `INSERT INTO ${this.meta.table} (${cols.join(",")}) VALUES (${pValues.join(",")}) RETURNING *`;
+        return this.dbContext.getDbQuery({
+            name: `insert into ${this.meta.table}`,
+            sql,
+            params: params,
+        });
+    }
+    // https://www.postgresqltutorial.com/postgresql-upsert/
+    // https://postgrespro.ru/docs/postgrespro/9.6/sql-insert
+    upsert(values, o) {
+        const { unique } = o;
+        const params = [];
+        const cols = [];
+        const pValues = [];
+        const indexes = {};
+        Object.keys(values).forEach((key, i) => {
+            cols.push(key);
+            const idx = i + 1;
+            indexes[key] = idx;
+            pValues.push("$" + idx);
+            params.push(values[key] ?? null);
+        });
+        const updated = cols.filter((x) => !unique.includes(x));
+        let doStatement = "NOTHING";
+        if (updated.length) {
+            const excluded = updated.map((x) => `${x} = EXCLUDED.${x}`);
+            doStatement = `UPDATE SET ${excluded.join(",")}`;
+        }
+        const sql = `INSERT INTO ${this.meta.table} (${cols.join(",")}) VALUES (${pValues.join(",")}) ON CONFLICT(${unique.join(",")}) DO ${doStatement} RETURNING *`;
+        return this.dbContext.getDbQuery({
+            name: `upsert into ${this.meta.table}`,
+            sql,
+            params: params,
+        });
+    }
+    update(values, where) {
+        let whereData = {};
+        const fillWhere = (whereColumns) => {
+            for (const col of whereColumns) {
+                ;
+                whereData[col] = values[col] ?? null;
+                delete values[col];
+            }
+        };
+        if (where) {
+            if (Array.isArray(where)) {
+                fillWhere(where);
+            }
+            else {
+                whereData = { ...where };
+            }
+        }
+        else {
+            const whereColumns = this.primaryKeys.map((x) => x.name);
+            fillWhere(whereColumns);
+        }
+        const params = [];
+        let i = 0;
+        const setData = { ...values };
+        const setExpr = [];
+        Object.keys(setData).forEach((key) => {
+            i++;
+            setExpr.push(`${key} = $${i}`);
+            params.push(setData[key] ?? null);
+        });
+        const whereExpr = [];
+        Object.keys(whereData).forEach((key) => {
+            const v = whereData[key] ?? null;
+            if (v === null) {
+                whereExpr.push(`(${key} IS NULL)`);
+            }
+            else {
+                i++;
+                whereExpr.push(`(${key} = $${i})`);
+                params.push(v);
+            }
+        });
+        const sql = `UPDATE ${this.meta.table} SET ${setExpr.join(",")} WHERE ${whereExpr.join(" AND ")}`;
+        return this.dbContext.getDbQuery({
+            name: `update of ${this.meta.table}`,
+            sql,
+            params: params,
+        });
+    }
+    del(values) {
+        return this.withTableWhere("DELETE", values, undefined);
+    }
+}

package/dist/{db-context → es/db-context}/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./db-context";
 export * from "./db-model";
 export * from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/db-context/index.js

@@ -0,0 +1,4 @@
+// created from 'create-ts-index'
+export * from "./db-context";
+export * from "./db-model";
+export * from "./types";

package/dist/{db-context → es/db-context}/types.d.ts

@@ -1,4 +1,4 @@
-import { DbClientFactory, DbQuery, DbQueryArgs } from "../db-client/db-client";
+import type { DbClientFactory, DbQuery, DbQueryArgs } from "../db-client/db-client";
 export declare namespace DbContext {
     interface Column {
         name: string;
@@ -25,14 +25,22 @@ export declare namespace DbContext {
         limit?: number;
         offset?: number;
     }
+    interface OrderByOptions<T = any> {
+        orderBy?: keyof T | `${string & keyof T} desc` | `${string & keyof T} asc`;
+    }
+    interface SelectOptions<T = any> extends Paging, OrderByOptions<T> {
+    }
     interface Model {
         dbContext: Context;
     }
     type Query<T> = DbQuery<T>;
     interface ModelApi<T> {
-        findAll(paging?: Paging): Query<T>;
+        findAll(opts?: SelectOptions): Query<T>;
         findById(id: unknown): Query<T>;
-        findBy(values: Partial<T>): Query<T>;
+        findBy(values: Partial<T>, opts?: SelectOptions): Query<T>;
+        insert(values: Partial<T>): Query<T>;
+        del(values: Partial<T>): DbContext.Query<T>;
+        update(values: Partial<T>, where?: (keyof T)[] | Partial<T>): DbContext.Query<T>;
     }
     interface Context {
         getDbClient: DbClientFactory<unknown>;
@@ -40,4 +48,3 @@ export declare namespace DbContext {
         getDbModel<T>(name: string): T;
     }
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/es/db-context/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{index.d.ts → es/index.d.ts}

@@ -2,4 +2,3 @@ export * from "./db-client";
 export * from "./db-context";
 export * from "./pg";
 export * from "./pg-db-client";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/index.js

@@ -0,0 +1,5 @@
+// created from 'create-ts-index'
+export * from "./db-client";
+export * from "./db-context";
+export * from "./pg";
+export * from "./pg-db-client";

package/dist/es/pg/index.d.ts

@@ -0,0 +1 @@
+export * from "./pg-pool-base";

package/dist/es/pg/index.js

@@ -0,0 +1,2 @@
+// created from 'create-ts-index'
+export * from "./pg-pool-base";

package/dist/{pg → es/pg}/pg-pool-base.d.ts

@@ -1,5 +1,6 @@
 import { MemoryCacheBase } from "@art-ws/common";
-import { Pool, PoolClient } from "pg";
+import { Pool } from "pg";
+import type { PoolClient } from "pg";
 export interface PgConnectionOptions {
     PGHOST: string;
     PGDATABASE: string;
@@ -23,4 +24,3 @@ export declare class PgPool {
     acquire(): Promise<PoolClient>;
     end(): void;
 }
-//# sourceMappingURL=pg-pool-base.d.ts.map

package/dist/{pg → es/pg}/pg-pool-base.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PgPool = exports.PgPoolsBase = void 0;
-const common_1 = require("@art-ws/common");
-const slf_1 = require("@art-ws/slf");
+import { MemoryCacheBase, racePromise } from "@art-ws/common";
+import { getLogger } from "@art-ws/slf";
 // https://node-postgres.com/
 // https://node-postgres.com/api/cursor
-const pg_1 = require("pg");
+import { Pool } from "pg";
 const getPoolKey = (o) => `postgres://${o.PGHOST || "-"}:${o.PGPORT || "-"}/${o.PGDATABASE || "-"}`;
 const toPoolConfig = (o) => {
     return {
@@ -16,20 +13,23 @@ const toPoolConfig = (o) => {
         host: o.PGHOST || "localhost",
     };
 };
-class PgPoolsBase {
+export class PgPoolsBase {
+    cache;
+    timeToIdle;
+    logger = getLogger(PgPoolsBase);
     constructor(cache, timeToIdle) {
         this.cache = cache;
         this.timeToIdle = timeToIdle;
-        this.logger = slf_1.getLogger(PgPoolsBase);
     }
     async acquire(options) {
         const key = getPoolKey(options);
         this.logger.trace(() => [{ key }, "acquire"]);
-        const result = await common_1.racePromise(key, async () => {
+        const result = await racePromise(key, async () => {
             this.logger.trace(() => [{ key }, "acquire(racePromise)"]);
             const pool = this.cache.getOrUpdate(key, () => new PgPool(key, options), {
                 timeToIdle: this.timeToIdle,
                 onRemove: (pool) => {
+                    this.logger.trace(() => [{ key }, "end"]);
                     pool.end();
                 },
             });
@@ -39,19 +39,30 @@ class PgPoolsBase {
         return result;
     }
 }
-exports.PgPoolsBase = PgPoolsBase;
 // https://node-postgres.com/api/client
-class PgPool {
+export class PgPool {
+    key;
+    options;
+    logger = getLogger(PgPool);
+    pool;
     constructor(key, options) {
         this.key = key;
         this.options = options;
-        this.logger = slf_1.getLogger(PgPool);
-        this.pool = new pg_1.Pool(toPoolConfig(options));
+        this.pool = new Pool(toPoolConfig(options));
+        this.logger.trace(() => [{ key }, "Pool created."]);
     }
     async acquire() {
-        this.logger.trace(() => ["acquire..."]);
-        const client = await this.pool.connect();
-        this.logger.trace(() => ["acquire"]);
+        const { pool, logger } = this;
+        logger.debug(() => [
+            {
+                totalCount: pool.totalCount,
+                waitingCount: pool.waitingCount,
+                idleCount: pool.idleCount,
+            },
+            "Connecting...",
+        ]);
+        const client = await pool.connect();
+        logger.debug(() => ["Connected"]);
         return client;
     }
     end() {
@@ -61,5 +72,3 @@ class PgPool {
         });
     }
 }
-exports.PgPool = PgPool;
-//# sourceMappingURL=pg-pool-base.js.map

package/dist/{pg-db-client → es/pg-db-client}/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./pg-db-client";
 export * from "./pg-db-query";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/pg-db-client/index.js

@@ -0,0 +1,3 @@
+// created from 'create-ts-index'
+export * from "./pg-db-client";
+export * from "./pg-db-query";

package/dist/es/pg-db-client/pg-db-client.d.ts

@@ -0,0 +1,13 @@
+import type { PoolClient, QueryArrayConfig, QueryConfig, QueryResult } from "pg";
+import type { DbClient } from "../db-client";
+export declare class PgDbClient implements DbClient<PoolClient> {
+    private pgClientFactory;
+    logger: import("@art-ws/slf").Logger;
+    constructor(pgClientFactory: () => Promise<PoolClient>);
+    private pgClient?;
+    dispose(): void;
+    private ensureClient;
+    queryInternal(queryConfig: QueryConfig | QueryArrayConfig): Promise<QueryResult<any>>;
+    getUnderlying(): Promise<PoolClient>;
+    cancel(_reason?: string | Error): Promise<void>;
+}