@primate/postgresql 0.3.0 → 0.5.0

package/lib/private/ColumnTypes.d.ts

@@ -1,4 +1,4 @@
-import type TypedArray from "@rcompat/type/TypedArray";
+import type { TypedArray } from "@rcompat/type";
 type Param = Array<unknown> | bigint | boolean | Date | null | number | object | string | TypedArray;
 type Validate<T extends {
     [K in keyof T]: Param;

package/lib/private/PostgreSQL.d.ts

@@ -0,0 +1,48 @@
+import type { As, DataDict, DB, Sort, With } from "@primate/core/db";
+import type { Dict } from "@rcompat/type";
+import type { StoreSchema } from "pema";
+declare const schema: import("pema").ObjectType<{
+    database: import("pema").StringType;
+    host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+    password: import("pema").OptionalType<import("pema").StringType>;
+    port: import("pema").DefaultType<import("pema").UintType<"u32">, 5432>;
+    username: import("pema").OptionalType<import("pema").StringType>;
+}>;
+export default class PostgreSQL implements DB {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input, options?: {
+        debug?: boolean;
+    });
+    close(): Promise<void>;
+    get explain(): Dict<{
+        query: string;
+        plans: string[];
+    }>;
+    get schema(): {
+        create: (as: As, store: StoreSchema) => Promise<void>;
+        delete: (name: string) => Promise<void>;
+    };
+    create<O extends Dict>(as: As, record: Dict): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        where: DataDict;
+        with?: never;
+    }): Promise<number>;
+    read(as: As, args: {
+        where: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        set: DataDict;
+        where: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        where: DataDict;
+    }): Promise<number>;
+}
+export {};
+//# sourceMappingURL=PostgreSQL.d.ts.map

package/lib/private/PostgreSQL.js

@@ -0,0 +1,493 @@
+import typemap from "#typemap";
+import common from "@primate/core/db";
+import E from "@primate/core/db/error";
+import sql from "@primate/core/db/sql";
+import assert from "@rcompat/assert";
+import is from "@rcompat/is";
+import p from "pema";
+import postgres from "postgres";
+const VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function Q(strings, ...values) {
+    return strings.reduce((result, string, i) => {
+        if (i === values.length)
+            return result + string;
+        const value = values[i];
+        let processed;
+        if (Array.isArray(value)) {
+            processed = value.join(", ");
+        }
+        else if (typeof value === "string") {
+            processed = quote(value);
+        }
+        else {
+            throw "Q: use only strings or arrays";
+        }
+        return result + string + processed;
+    }, "");
+}
+function is_bigint_key(k) {
+    return k === "u64" || k === "u128" || k === "i64" || k === "i128";
+}
+function quote(name) {
+    if (!VALID_IDENTIFIER.test(name))
+        throw E.identifier_invalid(name);
+    return `"${name}"`;
+}
+function order_by(types, sort, alias) {
+    if (sort === undefined)
+        return "";
+    const entries = Object.entries(sort);
+    if (entries.length === 0)
+        return "";
+    const parts = entries.map(([k, dir]) => {
+        const d = String(dir).toLowerCase();
+        const direction = d === "desc" ? "DESC" : "ASC";
+        const base = alias !== undefined ? `${alias}.${quote(k)}` : quote(k);
+        const datatype = types[k];
+        // if bigint-ish might be stored as TEXT/NUMERIC, force numeric ordering
+        const expression = is_bigint_key(datatype) ? `(${base})::numeric` : base;
+        return `${expression} ${direction}`;
+    });
+    return ` ORDER BY ${parts.join(", ")}`;
+}
+function get_column(key) {
+    return typemap[key].column;
+}
+async function bind_value(key, value) {
+    if (value === null)
+        return null;
+    // typemap.bind may be sync or async; allow both
+    return await typemap[key].bind(value);
+}
+function unbind_value(key, value) {
+    return typemap[key].unbind(value);
+}
+function unbind(types, row) {
+    return sql.unbind(types, row, unbind_value);
+}
+function relation_order(types, sort) {
+    if (sort === undefined)
+        return "";
+    const entries = Object.entries(sort);
+    if (entries.length === 0)
+        return "";
+    return entries.map(([k, dir]) => {
+        const direction = dir.toLowerCase() === "desc" ? "DESC" : "ASC";
+        const expression = k in types && is_bigint_key(types[k])
+            ? Q `(${k})::numeric`
+            : Q `${k}`;
+        return `${expression} ${direction}`;
+    }).join(", ");
+}
+const BIND_BY = "$";
+const schema = p({
+    database: p.string,
+    host: p.string.default("localhost"),
+    password: p.string.optional(),
+    port: p.uint.port().default(5432),
+    username: p.string.optional(),
+});
+export default class PostgreSQL {
+    static config;
+    #factory;
+    #client;
+    #debug = false;
+    #explain = {};
+    constructor(config, options) {
+        const parsed = schema.parse(config);
+        this.#factory = () => postgres({
+            db: parsed.database,
+            host: parsed.host,
+            port: parsed.port,
+            user: parsed.username,
+            pass: parsed.password,
+        });
+        this.#debug = options?.debug ?? false;
+    }
+    get #db() {
+        return (this.#client ??= this.#factory());
+    }
+    async #sql(q, params) {
+        return await this.#db.unsafe(q, params);
+    }
+    async #capture(name, query, params) {
+        if (!this.#debug)
+            return;
+        // Keep stored query exactly as executed (like SQLite)
+        // but EXPLAIN must not end with a semicolon.
+        const explain_target = query.trim().replace(/;+\s*$/, "");
+        const rows = await this.#sql(`EXPLAIN ${explain_target}`, params);
+        const plans = rows.map(r => r["QUERY PLAN"]);
+        this.#explain[name] = { query, plans };
+    }
+    async close() {
+        await this.#db.end();
+    }
+    get explain() {
+        return this.#explain;
+    }
+    async #where(as, where, index = 1, alias) {
+        const keys = Object.keys(where);
+        if (keys.length === 0)
+            return { WHERE: "", params: [], next_index: index };
+        const parts = [];
+        const params = [];
+        let i = index;
+        for (const field of keys) {
+            const raw = where[field];
+            const datatype = as.types[field];
+            const base = alias ? `${alias}.${quote(field)}` : quote(field);
+            if (raw === null) {
+                parts.push(`${base} IS NULL`);
+                continue;
+            }
+            // operator object
+            if (is.dict(raw)) {
+                const ops = Object.entries(raw);
+                if (ops.length === 0)
+                    throw E.operator_empty(field);
+                for (const [op, op_value] of ops) {
+                    const ph = `$${i++}`;
+                    // bigint comparisons must be numeric, regardless of storage.
+                    const numeric = is_bigint_key(datatype);
+                    const lhs = numeric ? `(${base})::numeric` : base;
+                    const rhs = numeric ? `${ph}::numeric` : ph;
+                    switch (op) {
+                        case "$like":
+                            parts.push(`${base} LIKE ${ph}`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        case "$ilike":
+                            parts.push(`${base} ILIKE ${ph}`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        case "$ne":
+                            parts.push(`${lhs} != ${rhs}`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        case "$gt":
+                        case "$gte":
+                        case "$lt":
+                        case "$lte":
+                        case "$after":
+                        case "$before": {
+                            const sql_op = sql.OPS[op];
+                            parts.push(`${lhs} ${sql_op} ${rhs}`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        }
+                        default:
+                            throw E.operator_unknown(field, op);
+                    }
+                }
+                continue;
+            }
+            // scalar equality
+            const ph = `$${i++}`;
+            parts.push(`${base} = ${ph}`);
+            params.push(await bind_value(datatype, raw));
+        }
+        return {
+            WHERE: `WHERE ${parts.join(" AND ")}`,
+            params,
+            next_index: i,
+        };
+    }
+    get schema() {
+        return {
+            create: async (as, store) => {
+                const columns = [];
+                for (const [key, value] of Object.entries(store)) {
+                    const column_type = get_column(value.datatype);
+                    const column = quote(key);
+                    if (key === as.pk) {
+                        const is_int = ["INTEGER", "BIGINT"].includes(column_type);
+                        if (as.generate_pk && is_int) {
+                            const serial = column_type === "BIGINT" ? "BIGSERIAL" : "SERIAL";
+                            columns.push(`${column} ${serial} PRIMARY KEY`);
+                        }
+                        else {
+                            columns.push(`${column} ${column_type} PRIMARY KEY`);
+                        }
+                    }
+                    else {
+                        columns.push(`${column} ${column_type}`);
+                    }
+                }
+                await this.#sql(Q `CREATE TABLE IF NOT EXISTS ${as.table} (${columns})`);
+            },
+            delete: async (name) => {
+                await this.#sql(Q `DROP TABLE IF EXISTS ${name}`);
+            },
+        };
+    }
+    async #generate_pk(as) {
+        const pk = as.pk;
+        const type = as.types[pk];
+        if (type === "string")
+            return crypto.randomUUID();
+        if (common.BIGINT_STRING_TYPES.includes(type)) {
+            const q = Q `SELECT MAX((${pk})::numeric)::text AS v FROM ${as.table}`;
+            const rows = await this.#sql(q);
+            return rows[0]?.v ? BigInt(rows[0].v) + 1n : 1n;
+        }
+        throw "unreachable";
+    }
+    #create(record) {
+        const fields = Object.keys(record);
+        return [
+            fields.map(quote),
+            fields.map((_, i) => `${BIND_BY}${i + 1}`),
+        ];
+    }
+    async #create_params(as, record) {
+        const fields = Object.keys(record);
+        const params = [];
+        for (const field of fields) {
+            params.push(await bind_value(as.types[field], record[field]));
+        }
+        return params;
+    }
+    async create(as, record) {
+        assert.dict(record);
+        const pk = as.pk;
+        const has_values = Object.keys(record).length > 0;
+        const table = as.table;
+        // PK provided or none defined, simple insert
+        if (pk === null || pk in record) {
+            if (!has_values) {
+                await this.#sql(Q `INSERT INTO ${table} DEFAULT VALUES`);
+                return record;
+            }
+            const [keys, values] = this.#create(record);
+            const params = await this.#create_params(as, record);
+            const q = Q `INSERT INTO ${table} (${keys}) VALUES (${values})`;
+            await this.#sql(q, params);
+            return record;
+        }
+        // PK missing
+        if (as.generate_pk === false)
+            throw E.pk_required(pk);
+        const type = as.types[pk];
+        // integer types, use RETURNING
+        if (!is_bigint_key(type) && type !== "string") {
+            const [keys, values] = this.#create(record);
+            const params = await this.#create_params(as, record);
+            const q = has_values
+                ? Q `INSERT INTO ${table} (${keys}) VALUES (${values}) RETURNING ${pk}`
+                : Q `INSERT INTO ${table} DEFAULT VALUES RETURNING ${pk}`;
+            const rows = await this.#sql(q, params);
+            const pk_value = unbind_value(type, rows[0][pk]);
+            return { ...record, [pk]: pk_value };
+        }
+        // string or bigint, generate manually
+        const pk_value = await this.#generate_pk(as);
+        const to_insert = { ...record, [pk]: pk_value };
+        const [keys, values] = this.#create(to_insert);
+        const params = await this.#create_params(as, to_insert);
+        const q = Q `INSERT INTO ${table} (${keys}) VALUES (${values})`;
+        await this.#sql(q, params);
+        return to_insert;
+    }
+    async read(as, args) {
+        assert.dict(args.where);
+        this.#explain = {};
+        if (args.count === true)
+            return this.#count(as, args.where);
+        if (common.withed(args)) {
+            return sql.joinable(as, args.with)
+                ? this.#read_joined(as, args)
+                : this.#read_phased(as, args);
+        }
+        return this.#read(as, args);
+    }
+    async #count(as, where) {
+        const { WHERE, params } = await this.#where(as, where);
+        const q = `SELECT COUNT(*)::text AS n FROM ${quote(as.table)} ${WHERE}`;
+        const rows = await this.#sql(q, params);
+        await this.#capture(as.table, q, params);
+        return Number(rows[0]?.n ?? 0);
+    }
+    async #base_query(as, args) {
+        const SELECT = args.fields === undefined
+            ? "*"
+            : args.fields.map(quote).join(", ");
+        const table = quote(as.table);
+        const { WHERE, params } = await this.#where(as, args.where);
+        const ORDER_BY = order_by(as.types, args.sort);
+        const LIMIT = sql.limit(args.limit);
+        return {
+            query: `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}`,
+            params,
+        };
+    }
+    async #read_joined(as, args) {
+        if (as.pk === null)
+            throw E.relation_requires_pk("parent");
+        const [[, relation]] = Object.entries(args.with);
+        if (relation.as.pk === null)
+            throw E.relation_requires_pk("target");
+        const aliases = sql.aliases([as.table, relation.as.table]);
+        const alias = aliases[as.table];
+        const r_alias = aliases[relation.as.table];
+        const fields = common.fields(args.fields, as.pk) ?? Object.keys(as.types);
+        const r_fields = common.fields(relation.fields, relation.fk, relation.as.pk)
+            ?? Object.keys(relation.as.types);
+        const SELECT = [
+            ...fields.map(f => `${alias}.${quote(f)} AS ${alias}_${f}`),
+            ...r_fields.map(f => `${r_alias}.${quote(f)} AS ${r_alias}_${f}`),
+        ].join(", ");
+        const { query, params } = await this.#base_query(as, { ...args, fields });
+        const JOIN = `LEFT JOIN ${quote(relation.as.table)} ${r_alias}
+      ON ${r_alias}.${quote(relation.fk)} = ${alias}.${quote(as.pk)}`;
+        const q = `SELECT ${SELECT} FROM (${query}) ${alias}
+      ${JOIN}${order_by(as.types, args.sort, alias)}`;
+        const rows = await this.#sql(q, params);
+        await this.#capture(as.table, q, params);
+        return sql.nest(as, { rows, aliases }, args, unbind_value);
+    }
+    async #read(as, args) {
+        const { query, params } = await this.#base_query(as, args);
+        const rows = await this.#sql(query, params);
+        await this.#capture(as.table, query, params);
+        return rows.map(r => unbind(as.types, r));
+    }
+    async #read_phased(as, args) {
+        const fields = common.expand(as, args.fields, args.with);
+        const rows = await this.#read(as, { ...args, fields });
+        const out = rows.map(row => common.project(row, args.fields));
+        for (const [table, relation] of Object.entries(args.with)) {
+            await this.#attach_relation(as, { rows, out, table, relation });
+        }
+        return out;
+    }
+    async #attach_relation(as, args) {
+        const relation = args.relation;
+        const by = relation.reverse ? relation.as.pk : relation.fk;
+        if (by === null)
+            throw E.relation_requires_pk("target");
+        const parent_by = relation.reverse ? relation.fk : as.pk;
+        if (parent_by === null)
+            throw E.relation_requires_pk("parent");
+        const join_values = [...new Set(args.rows.map(r => r[parent_by]).filter(v => v != null))];
+        const is_many = relation.kind === "many";
+        const many = is_many ? [] : null;
+        if (join_values.length === 0) {
+            for (const row of args.out)
+                row[args.table] = many;
+            return;
+        }
+        const related = await this.#load_related({ by, join_values, ...relation });
+        const grouped = new Map();
+        for (const row of related) {
+            const key = row[by];
+            if (key === null)
+                continue;
+            if (!grouped.has(key))
+                grouped.set(key, []);
+            grouped.get(key).push(row);
+        }
+        for (let i = 0; i < args.out.length; i++) {
+            const join_value = args.rows[i][parent_by];
+            if (join_value == null) {
+                args.out[i][args.table] = is_many ? [] : null;
+                continue;
+            }
+            const rows = grouped.get(join_value) ?? [];
+            args.out[i][args.table] = is_many
+                ? rows.map(r => common.project(r, relation.fields))
+                : rows[0] ? common.project(rows[0], relation.fields) : null;
+        }
+    }
+    async #load_related(args) {
+        const per_parent = args.kind === "one" ? 1 : args.limit;
+        // build WHERE, excluding the IN clause
+        const { WHERE: _where, params: where_params, next_index } = await this.#where(args.as, args.where);
+        const where_part = _where.length > 0 ? _where.slice("WHERE ".length) : "";
+        // build IN (...) placeholders and binds
+        const datatype = args.as.types[args.by];
+        const numeric = is_bigint_key(datatype);
+        let next_i = next_index;
+        const in_placeholders = [];
+        const in_params = [];
+        for (const v of args.join_values) {
+            const ph = `$${next_i++}`;
+            in_placeholders.push(numeric ? `${ph}::numeric` : ph);
+            in_params.push(await bind_value(datatype, v));
+        }
+        const lhs = numeric ? `(${quote(args.by)})::numeric` : quote(args.by);
+        const in_part = `${lhs} IN (${in_placeholders.join(", ")})`;
+        const WHERE = where_part
+            ? `WHERE (${where_part}) AND (${in_part})`
+            : `WHERE ${in_part}`;
+        // SELECT fields, must include `by` for grouping
+        const all_columns = Object.keys(args.as.types);
+        const fields = args.fields !== undefined && args.fields.length > 0
+            ? args.fields
+            : all_columns;
+        const select_fields = [...new Set([...fields, args.by])];
+        const SELECT = select_fields.map(quote).join(", ");
+        // relation sort, used both for row_number ranking and final ordering
+        const user_order = relation_order(args.as.types, args.sort);
+        const base_order = numeric
+            ? `(${quote(args.by)})::numeric ASC`
+            : `${quote(args.by)} ASC`;
+        const ORDER_BY = user_order
+            ? ` ORDER BY ${base_order}, ${user_order}`
+            : ` ORDER BY ${base_order}`;
+        let q;
+        const table = quote(args.as.table);
+        if (per_parent !== undefined) {
+            const rn_order = user_order ? ` ORDER BY ${user_order}` : "";
+            q = `
+        WITH ranked AS (
+          SELECT
+            ${SELECT},
+            ROW_NUMBER() OVER (
+              PARTITION BY ${numeric ? Q `(${args.by})::numeric` : Q `${args.by}`}
+              ${rn_order}
+            ) AS __rn
+          FROM ${table}
+          ${WHERE}
+        )
+        SELECT ${SELECT}
+        FROM ranked
+        WHERE __rn <= ${per_parent}
+        ${ORDER_BY}
+      `;
+        }
+        else {
+            q = `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}`;
+        }
+        const params = [...where_params, ...in_params];
+        const rows = await this.#sql(q, params);
+        await this.#capture(args.as.table, q, params);
+        return rows.map(r => unbind(args.as.types, r));
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        const set_keys = Object.keys(args.set);
+        const set_parts = [];
+        const set_params = [];
+        let i = 1;
+        for (const k of set_keys) {
+            const ph = `$${i++}`;
+            set_parts.push(`${quote(k)} = ${ph}`);
+            set_params.push(await bind_value(as.types[k], args.set[k]));
+        }
+        const SET = `SET ${set_parts.join(", ")}`;
+        const { WHERE, params } = await this.#where(as, args.where, i);
+        const q = `UPDATE ${quote(as.table)} ${SET} ${WHERE} RETURNING 1`;
+        const rows = await this.#sql(q, [...set_params, ...params]);
+        return rows.length;
+    }
+    async delete(as, args) {
+        assert.nonempty(args.where);
+        const { WHERE, params } = await this.#where(as, args.where);
+        const q = `DELETE FROM ${quote(as.table)} ${WHERE} RETURNING 1`;
+        const rows = await this.#sql(q, params);
+        return rows.length;
+    }
+}
+//# sourceMappingURL=PostgreSQL.js.map

package/lib/private/typemap.d.ts

@@ -1,5 +1,5 @@
 import type ColumnTypes from "#ColumnTypes";
-import type TypeMap from "@primate/core/database/TypeMap";
+import type { TypeMap } from "@primate/core/db";
 declare const typemap: TypeMap<ColumnTypes>;
 export default typemap;
 //# sourceMappingURL=typemap.d.ts.map

package/lib/private/typemap.js

@@ -48,18 +48,6 @@ const typemap = {
         },
     },
     i8: number("SMALLINT"),
-    primary: {
-        bind(value) {
-            if (typeof value === "string" && Number.isInteger(+value)) {
-                return Number(value);
-            }
-            throw new Error(`\`${value}\` is not a valid primary key value`);
-        },
-        column: "SERIAL PRIMARY KEY",
-        unbind(value) {
-            return String(value);
-        },
-    },
     string: identity("TEXT"),
     time: identity("TIME"),
     u128: {

package/lib/public/index.d.ts

@@ -1,4 +1,4 @@
-import Database from "#Database";
-declare const _default: (config: typeof Database.config) => Database;
+import PostgreSQL from "#PostgreSQL";
+declare const _default: (config: typeof PostgreSQL.config) => PostgreSQL;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -1,3 +1,3 @@
-import Database from "#Database";
-export default (config) => new Database(config);
+import PostgreSQL from "#PostgreSQL";
+export default (config) => new PostgreSQL(config);
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,28 +1,34 @@
 {
   "name": "@primate/postgresql",
-  "version": "0.3.0",
-  "description": "Primate PostgreSQL database",
+  "version": "0.5.0",
+  "description": "PostgreSQL databases for Primate",
   "homepage": "https://primate.run/docs/database/postgresql",
   "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
   "license": "MIT",
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/primate-run/primate",
     "directory": "packages/postgresql"
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
   "dependencies": {
-    "@rcompat/assert": "^0.3.1",
-    "@rcompat/record": "^0.9.1",
-    "pema": "",
-    "postgres": "^3.4.7",
-    "@primate/core": "^0.3.0"
+    "@rcompat/assert": "^0.6.0",
+    "@rcompat/is": "^0.4.2",
+    "postgres": "^3.4.8",
+    "@primate/core": "^0.5.0",
+    "pema": "0.5.0"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.9.0"
+  },
+  "peerDependencies": {
+    "primate": "^0.36.0"
   },
-  "type": "module",
   "imports": {
     "#*": {
       "apekit": "./src/private/*.ts",

package/lib/private/Database.d.ts

@@ -1,46 +0,0 @@
-import Database from "@primate/core/Database";
-import type As from "@primate/core/database/As";
-import type DataDict from "@primate/core/database/DataDict";
-import type TypeMap from "@primate/core/database/TypeMap";
-import type Dict from "@rcompat/type/Dict";
-import type StoreSchema from "pema/StoreSchema";
-declare const schema: import("pema").ObjectType<{
-    database: import("pema/string").StringType;
-    host: import("pema").DefaultType<import("pema/string").StringType, "localhost">;
-    password: import("pema").OptionalType<import("pema/string").StringType>;
-    port: import("pema").DefaultType<import("pema/uint").UintType<"u32">, 5432>;
-    username: import("pema").OptionalType<import("pema/string").StringType>;
-}>;
-export default class PostgreSQLDatabase extends Database {
-    #private;
-    static config: typeof schema.input;
-    constructor(config?: typeof schema.input);
-    get typemap(): TypeMap<Dict>;
-    close(): Promise<void>;
-    get schema(): {
-        create: (name: string, store: StoreSchema) => Promise<void>;
-        delete: (name: string) => Promise<void>;
-    };
-    create<O extends Dict>(as: As, args: {
-        record: DataDict;
-    }): Promise<O>;
-    read(as: As, args: {
-        count: true;
-        criteria: DataDict;
-    }): Promise<number>;
-    read(as: As, args: {
-        criteria: DataDict;
-        fields?: string[];
-        limit?: number;
-        sort?: Dict<"asc" | "desc">;
-    }): Promise<Dict[]>;
-    update(as: As, args: {
-        changes: DataDict;
-        criteria: DataDict;
-    }): Promise<any>;
-    delete(as: As, args: {
-        criteria: DataDict;
-    }): Promise<any>;
-}
-export {};
-//# sourceMappingURL=Database.d.ts.map

package/lib/private/Database.js

@@ -1,166 +0,0 @@
-import typemap from "#typemap";
-import Database from "@primate/core/Database";
-import assert from "@rcompat/assert";
-import maybe from "@rcompat/assert/maybe";
-import pema from "pema";
-import string from "pema/string";
-import uint from "pema/uint";
-import postgres from "postgres";
-const schema = pema({
-    database: string,
-    host: string.default("localhost"),
-    password: string.optional(),
-    port: uint.port().default(5432),
-    username: string.optional(),
-});
-export default class PostgreSQLDatabase extends Database {
-    static config;
-    #factory;
-    #client;
-    constructor(config) {
-        super();
-        const parsed = schema.parse(config);
-        this.#factory = () => postgres({
-            db: parsed.database,
-            host: parsed.host,
-            pass: parsed.password,
-            port: parsed.port,
-            user: parsed.username,
-        });
-    }
-    #sql() {
-        if (this.#client === undefined) {
-            this.#client = this.#factory();
-        }
-        return this.#client;
-    }
-    #join(parts, sep) {
-        const sql = this.#sql();
-        if (parts.length === 0)
-            return sql ``;
-        return parts.slice(1).reduce((acc, p) => sql `${acc}${sep}${p}`, parts[0]);
-    }
-    async #new(name, store) {
-        const sql = this.#sql();
-        const table = sql(name);
-        const body = Object.entries(store).map(([k, v]) => sql `${sql(k)} ${sql.unsafe(this.column(v.datatype))}`);
-        await sql `CREATE TABLE IF NOT EXISTS ${table}
-      (${this.#join(body, sql `, `)})`;
-    }
-    async #drop(name) {
-        const sql = this.#sql();
-        await sql `DROP TABLE IF EXISTS ${sql(name)};`;
-    }
-    get typemap() {
-        return typemap;
-    }
-    async close() {
-        await this.#sql().end();
-    }
-    get schema() {
-        return {
-            create: this.#new.bind(this),
-            delete: this.#drop.bind(this),
-        };
-    }
-    async create(as, args) {
-        const sql = this.#sql();
-        const columns = Object.keys(args.record);
-        const binds = await this.bind(as.types, args.record);
-        const [result] = await sql `INSERT INTO
-      ${sql(as.name)}
-      ${columns.length > 0
-            ? sql `(${sql(columns)}) VALUES ${sql(binds)}`
-            : sql.unsafe("DEFAULT VALUES")}
-      RETURNING id;
-    `;
-        return this.unbind(as.types, { ...args.record, id: result.id });
-    }
-    #sort(types, sort) {
-        maybe(sort).object();
-        // validate
-        this.toSort(types, sort);
-        const sql = this.#sql();
-        if (!sort)
-            return sql ``;
-        const entries = Object.entries(sort);
-        if (entries.length === 0)
-            return sql ``;
-        const items = entries.map(([field, direction]) => sql `${sql(field)} ${sql.unsafe(direction.toUpperCase())}`);
-        return sql ` ORDER BY ${this.#join(items, sql `, `)}`;
-    }
-    #select(types, fields) {
-        // validate
-        this.toSelect(types, fields);
-        const sql = this.#sql();
-        if (fields === undefined)
-            return sql.unsafe("*");
-        return sql(fields);
-    }
-    #limit(limit) {
-        maybe(limit).usize();
-        const sql = this.#sql();
-        return limit === undefined ? sql `` : sql ` LIMIT ${limit}`;
-    }
-    #where(types, criteria, nonnull) {
-        this.toWhere(types, criteria); // validate
-        const sql = this.#sql();
-        const entries = Object.entries(criteria);
-        if (entries.length === 0)
-            return sql ``;
-        const clauses = entries.map(([key, raw]) => {
-            if (raw === null)
-                return sql `${sql(key)} IS NULL`;
-            const value = nonnull[key];
-            // Handle operator objects
-            if (typeof raw === "object") {
-                if ("$like" in raw)
-                    return sql `${sql(key)} LIKE ${value}`;
-                // if ("$gte" in raw) return sql`${sql(key)} >= ${nonnull[key]}`;
-            }
-            return sql `${sql(key)} = ${value}`;
-        });
-        return sql `WHERE ${this.#join(clauses, sql ` AND `)}`;
-    }
-    async read(as, args) {
-        const sql = this.#sql();
-        const table = sql(as.name);
-        const criteria = await this.bindCriteria(as.types, args.criteria);
-        const where = this.#where(as.types, args.criteria, criteria);
-        if (args.count === true) {
-            const [{ n }] = await sql `SELECT COUNT(*) AS n FROM ${table} ${where}`;
-            return Number(n);
-        }
-        const sort = this.#sort(as.types, args.sort);
-        const limit = this.#limit(args.limit);
-        const select = this.#select(as.types, args.fields);
-        const records = await sql `
-      SELECT ${select}
-      FROM ${table}
-      ${where}
-      ${sort}
-      ${limit}
-    `;
-        return records.map(record => this.unbind(as.types, record));
-    }
-    async update(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
-        const sql = this.#sql();
-        const table = sql(as.name);
-        const criteria = await this.bindCriteria(as.types, args.criteria);
-        const set_binds = await this.bind(as.types, args.changes);
-        const where = this.#where(as.types, args.criteria, criteria);
-        const set = sql({ ...set_binds });
-        return (await sql `UPDATE ${table} SET ${set} ${where} RETURNING 1;`).length;
-    }
-    async delete(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "delete: no criteria");
-        const sql = this.#sql();
-        const criteria = await this.bindCriteria(as.types, args.criteria);
-        const where = this.#where(as.types, args.criteria, criteria);
-        const table = sql(as.name);
-        return (await sql `DELETE FROM ${table} ${where} RETURNING 1;`).length;
-    }
-    ;
-}
-//# sourceMappingURL=Database.js.map