@primate/mysql 0.4.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 = bigint | boolean | Date | null | number | string | TypedArray;
 type Validate<T extends {
     [K in keyof T]: Param;

package/lib/private/MySQL.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">, 3306>;
+    username: import("pema").OptionalType<import("pema").StringType>;
+}>;
+export default class MySQL implements DB {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input, options?: {
+        debug?: boolean;
+    });
+    get explain(): Dict<{
+        query: string;
+        plans: string[];
+    }>;
+    close(): Promise<void>;
+    get schema(): {
+        create: (as: As, store: StoreSchema) => Promise<void>;
+        delete: (table: 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=MySQL.d.ts.map

package/lib/private/MySQL.js

@@ -0,0 +1,461 @@
+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 mysql from "mysql2/promise";
+import p from "pema";
+const BIND_BY = ":";
+const Q = sql.Q;
+function bigint_cast(arg) {
+    return `CAST(${arg} AS DECIMAL(65,0))`;
+}
+function is_bigint_key(k) {
+    return k === "u64" || k === "u128" || k === "i64" || k === "i128";
+}
+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 quoted = sql.quote(k);
+        const base = alias ? `${alias}.${quoted}` : quoted;
+        const expression = is_bigint_key(types[k]) ? bigint_cast(base) : base;
+        return `${expression} ${dir.toLowerCase() === "desc" ? "DESC" : "ASC"}`;
+    });
+    return ` ORDER BY ${parts.join(", ")}`;
+}
+function get_column(key) {
+    return typemap[key].column;
+}
+async function bind_value(key, value) {
+    if (value === null)
+        return null;
+    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);
+}
+const schema = p({
+    database: p.string,
+    host: p.string.default("localhost"),
+    password: p.string.optional(),
+    port: p.uint.port().default(3306),
+    username: p.string.optional(),
+});
+export default class MySQL {
+    static config;
+    #factory;
+    #client;
+    #debug = false;
+    #explain = {};
+    constructor(config, options) {
+        const parsed = schema.parse(config);
+        this.#factory = () => mysql.createPool({
+            host: parsed.host,
+            port: parsed.port,
+            database: parsed.database,
+            user: parsed.username,
+            password: parsed.password,
+            namedPlaceholders: true,
+            bigNumberStrings: true,
+            supportBigNumbers: true,
+        });
+        this.#debug = options?.debug ?? false;
+    }
+    get #db() {
+        return this.#client ??= this.#factory();
+    }
+    async #sql(query, params) {
+        const [rows] = await this.#db.query(query, params);
+        return rows;
+    }
+    async #execute(query, params) {
+        const [result] = await this.#db.execute(query, params);
+        return result;
+    }
+    async #capture(table, query, params) {
+        if (!this.#debug)
+            return;
+        const rows = await this.#sql(`EXPLAIN ${query}`, params);
+        this.#explain[table] = { query, plans: rows.map(r => JSON.stringify(r)) };
+    }
+    get explain() {
+        return this.#explain;
+    }
+    async close() {
+        await this.#db.end();
+    }
+    get schema() {
+        return {
+            create: async (as, store) => {
+                const columns = [];
+                for (const [key, value] of Object.entries(store)) {
+                    const type = get_column(value.datatype);
+                    if (key === as.pk) {
+                        const is_int = common.INT_TYPES.includes(value.datatype);
+                        const auto = as.generate_pk && is_int ? " AUTO_INCREMENT" : "";
+                        // 36 is UUID length
+                        const pk_type = value.datatype === "string" ? "VARCHAR(36)" : type;
+                        columns.push(`${sql.quote(key)} ${pk_type} PRIMARY KEY${auto}`);
+                    }
+                    else {
+                        columns.push(`${sql.quote(key)} ${type}`);
+                    }
+                }
+                await this.#sql(Q `CREATE TABLE IF NOT EXISTS ${as.table} (${columns})`);
+            },
+            delete: async (table) => {
+                await this.#sql(Q `DROP TABLE IF EXISTS ${table}`);
+            },
+        };
+    }
+    async #where(as, where) {
+        const fields = Object.keys(where);
+        if (fields.length === 0)
+            return ["", {}];
+        const parts = [];
+        const binds = {};
+        for (const field of fields) {
+            const value = where[field];
+            const datatype = as.types[field];
+            const q = sql.quote(field);
+            const quoted = q;
+            if (value === null) {
+                parts.push(`${quoted} IS NULL`);
+                continue;
+            }
+            if (is.dict(value)) {
+                const ops = Object.entries(value);
+                if (ops.length === 0)
+                    throw E.operator_empty(field);
+                for (const [op, op_value] of ops) {
+                    const bind_key = sql.bindKey(field, op);
+                    const ph = `${BIND_BY}${bind_key}`;
+                    const numeric = is_bigint_key(datatype);
+                    const lhs = numeric ? bigint_cast(quoted) : quoted;
+                    const rhs = numeric ? bigint_cast(ph) : ph;
+                    binds[bind_key] = await bind_value(datatype, op_value);
+                    switch (op) {
+                        case "$like":
+                            parts.push(`${quoted} LIKE BINARY ${ph}`);
+                            break;
+                        case "$ilike":
+                            parts.push(`LOWER(${quoted}) LIKE LOWER(${ph})`);
+                            break;
+                        case "$ne":
+                            parts.push(`${lhs} != ${rhs}`);
+                            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}`);
+                            break;
+                        }
+                        default:
+                            throw E.operator_unknown(field, op);
+                    }
+                }
+                continue;
+            }
+            parts.push(`${quoted} = ${BIND_BY}${field}`);
+            binds[field] = await bind_value(datatype, value);
+        }
+        return [`WHERE ${parts.join(" AND ")}`, binds];
+    }
+    #set(set) {
+        const columns = Object.keys(set);
+        if (columns.length === 0)
+            throw E.field_required("set");
+        return Q `SET ${columns.map(c => `${sql.quote(c)}=${BIND_BY}s_${c}`)}`;
+    }
+    async #bind_set(types, set) {
+        const columns = Object.keys(set);
+        if (columns.length === 0)
+            throw E.field_required("set");
+        const params = {};
+        for (const c of columns) {
+            params[`s_${c}`] = await bind_value(types[c], set[c]);
+        }
+        return params;
+    }
+    async #generate_pk(as) {
+        const pk = as.pk;
+        const type = as.types[pk];
+        const table = as.table;
+        if (type === "string")
+            return crypto.randomUUID();
+        if (common.BIGINT_STRING_TYPES.includes(type)) {
+            const cast = bigint_cast(sql.quote(pk));
+            const q = `SELECT MAX(${cast}) AS v FROM ${sql.quote(table)}`;
+            const rows = await this.#sql(q);
+            const v = rows[0]?.v;
+            return v ? BigInt(v) + 1n : 1n;
+        }
+        throw "unreachable";
+    }
+    #create(record) {
+        const fields = Object.keys(record);
+        return [
+            fields.map(sql.quote),
+            fields.map(field => `${BIND_BY}${field}`),
+        ];
+    }
+    async #create_params(types, record) {
+        const params = {};
+        for (const k of Object.keys(record)) {
+            params[k] = await bind_value(types[k], record[k]);
+        }
+        return params;
+    }
+    async create(as, record) {
+        assert.dict(record);
+        const pk = as.pk;
+        const table = as.table;
+        // PK provided or none defined, simple insert
+        if (pk === null || pk in record) {
+            const [keys, values] = this.#create(record);
+            const query = keys.length > 0
+                ? Q `INSERT INTO ${table} (${keys}) VALUES (${values})`
+                : Q `INSERT INTO ${table} () VALUES ()`;
+            await this.#sql(query, await this.#create_params(as.types, record));
+            return record;
+        }
+        if (as.generate_pk === false)
+            throw E.pk_required(pk);
+        const type = as.types[pk];
+        // integer types, use AUTO_INCREMENT
+        if (!common.BIGINT_STRING_TYPES.includes(type) && type !== "string") {
+            const [keys, values] = this.#create(record);
+            const query = keys.length > 0
+                ? Q `INSERT INTO ${table} (${keys}) VALUES (${values})`
+                : Q `INSERT INTO ${table} () VALUES ()`;
+            const result = await this.#execute(query, await this.#create_params(as.types, record));
+            const pk_value = unbind_value(type, result.insertId);
+            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 query = Q `INSERT INTO ${table} (${keys}) VALUES (${values})`;
+        await this.#sql(query, await this.#create_params(as.types, to_insert));
+        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, binds] = await this.#where(as, where);
+        const table = as.table;
+        const query = `SELECT COUNT(*) AS n FROM ${sql.quote(table)} ${WHERE}`;
+        const rows = await this.#sql(query, binds);
+        await this.#capture(table, query, binds);
+        return Number(rows[0]?.n ?? 0);
+    }
+    async #base_query(as, args) {
+        const SELECT = args.fields === undefined
+            ? "*"
+            : args.fields.map(sql.quote).join(", ");
+        const [WHERE, binds] = await this.#where(as, args.where);
+        const ORDER_BY = order_by(as.types, args.sort);
+        const LIMIT = sql.limit(args.limit);
+        const table = sql.quote(as.table);
+        return [
+            `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}`,
+            binds,
+        ];
+    }
+    async #read(as, args) {
+        const [query, binds] = await this.#base_query(as, args);
+        const rows = await this.#sql(query, binds);
+        await this.#capture(as.table, query, binds);
+        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];
+            grouped.set(key, grouped.get(key)?.concat(row) ?? [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] = many;
+                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;
+        const in_binds = {};
+        const placeholders = [];
+        for (let i = 0; i < args.join_values.length; i++) {
+            const key = `${args.by}__in${i}`;
+            in_binds[key] = await bind_value(args.as.types[args.by], args.join_values[i]);
+            placeholders.push(`${BIND_BY}${key}`);
+        }
+        const [where, where_binds] = await this.#where(args.as, args.where);
+        const where_part = where ? where.slice("WHERE ".length) : "";
+        const numeric = is_bigint_key(args.as.types[args.by]);
+        const in_placeholders = numeric
+            ? placeholders.map(bigint_cast)
+            : placeholders;
+        const cast = bigint_cast(sql.quote(args.by));
+        const lhs = numeric ? cast : Q `${args.by}`;
+        const in_part = `${lhs} IN (${in_placeholders.join(", ")})`;
+        const where_parts = where_part
+            ? [`(${where_part})`, `(${in_part})`]
+            : [in_part];
+        const WHERE = `WHERE ${where_parts.join(" AND ")}`;
+        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(sql.quote).join(", ");
+        const base_order = `${numeric ? cast : Q `${args.by}`} ASC`;
+        const user_order = order_by(args.as.types, args.sort)
+            .replace(/^ ORDER BY /, "");
+        const ORDER_BY = user_order
+            ? ` ORDER BY ${base_order}, ${user_order}`
+            : ` ORDER BY ${base_order}`;
+        const table = sql.quote(args.as.table);
+        let query;
+        if (per_parent !== undefined) {
+            const partition = numeric ? cast : Q `${args.by}`;
+            const rn_order = user_order ? ` ORDER BY ${user_order}` : "";
+            query = `
+        SELECT ${SELECT} FROM (
+          SELECT
+            ${SELECT},
+            ROW_NUMBER() OVER (
+              PARTITION BY ${partition}
+              ${rn_order}
+            ) AS __rn
+          FROM ${table}
+          ${WHERE}
+        ) ranked
+        WHERE __rn <= ${per_parent}
+        ${ORDER_BY}
+      `;
+        }
+        else {
+            query = `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}`;
+        }
+        const binds = { ...where_binds, ...in_binds };
+        const rows = await this.#sql(query, binds);
+        await this.#capture(args.as.table, query, binds);
+        return rows.map(r => unbind(args.as.types, r));
+    }
+    #join(as, aliases, relation) {
+        const parent_alias = aliases[as.table];
+        const alias = aliases[relation.as.table];
+        const table = sql.quote(relation.as.table);
+        const by = relation.reverse ? relation.as.pk : relation.fk;
+        const parent_by = relation.reverse ? relation.fk : as.pk;
+        if (by === null)
+            throw E.relation_requires_pk("target");
+        if (parent_by === null)
+            throw E.relation_requires_pk("parent");
+        const left = `${alias}.${sql.quote(by)}`;
+        const right = `${parent_alias}.${sql.quote(parent_by)}`;
+        return `LEFT JOIN ${table} ${alias} ON ${left} = ${right}`;
+    }
+    async #read_joined(as, args) {
+        if (as.pk === null)
+            throw E.relation_requires_pk("parent");
+        const tables = [as.table, ...Object.values(args.with).map(r => r.as.table)];
+        const aliases = sql.aliases(tables);
+        const alias = aliases[as.table];
+        const fields = common.fields(args.fields, as.pk) ?? Object.keys(as.types);
+        const SELECT = [
+            ...fields.map(f => `${alias}.${sql.quote(f)} AS ${alias}_${f}`),
+            ...Object.values(args.with).flatMap(relation => {
+                const r_alias = aliases[relation.as.table];
+                const r_fields = relation.as.pk !== null
+                    ? common.fields(relation.fields, relation.as.pk)
+                    : relation.fields;
+                return (r_fields ?? Object.keys(relation.as.types))
+                    .map(f => `${r_alias}.${sql.quote(f)} AS ${r_alias}_${f}`);
+            }),
+        ].join(", ");
+        const [SUBQUERY, binds] = await this.#base_query(as, { ...args, fields });
+        const FROM = `(${SUBQUERY}) ${alias}`;
+        const JOINS = Object.values(args.with)
+            .map(relation => this.#join(as, aliases, relation))
+            .join("\n");
+        const ORDER_BY = order_by(as.types, args.sort, alias);
+        const query = `SELECT ${SELECT} FROM ${FROM} ${JOINS} ${ORDER_BY}`;
+        const rows = await this.#sql(query, binds);
+        this.#capture(as.table, query, binds);
+        return sql.nest(as, { rows, aliases }, args, unbind_value);
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        const [WHERE, where_binds] = await this.#where(as, args.where);
+        const SET = this.#set(args.set);
+        const set_binds = await this.#bind_set(as.types, args.set);
+        const query = `UPDATE ${sql.quote(as.table)} ${SET} ${WHERE}`;
+        const binds = { ...where_binds, ...set_binds };
+        const result = await this.#execute(query, binds);
+        return result.affectedRows;
+    }
+    async delete(as, args) {
+        assert.nonempty(args.where);
+        const [WHERE, binds] = await this.#where(as, args.where);
+        const query = `DELETE FROM ${sql.quote(as.table)} ${WHERE}`;
+        const result = await this.#execute(query, binds);
+        return result.affectedRows;
+    }
+}
+//# sourceMappingURL=MySQL.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

@@ -1,4 +1,3 @@
-import numeric from "@rcompat/is/numeric";
 function identity(column) {
     return {
         bind: value => value,
@@ -16,8 +15,7 @@ function number(column) {
 const typemap = {
     blob: {
         async bind(value) {
-            const arrayBuffer = await value.arrayBuffer();
-            return new Uint8Array(arrayBuffer);
+            return new Uint8Array(await value.arrayBuffer());
         },
         column: "BLOB",
         unbind(value) {
@@ -57,18 +55,16 @@ const typemap = {
         },
     },
     i8: number("TINYINT"),
-    primary: {
-        bind(value) {
-            if (numeric(value)) {
-                return Number(value);
-            }
-            throw new Error(`\`${value}\` is not a valid primary key value`);
-        },
-        column: "INT NOT NULL AUTO_INCREMENT PRIMARY KEY",
-        unbind(value) {
-            return String(value);
-        },
-    },
+    /*primary: {
+      bind(value) {
+        if (is.numeric(value)) return Number(value);
+        throw new Error(`\`${value}\` is not a valid primary key value`);
+      },
+      column: "INT NOT NULL AUTO_INCREMENT PRIMARY KEY",
+      unbind(value) {
+        return String(value);
+      },
+    },*/
     string: identity("TEXT"),
     time: identity("TEXT"),
     u128: {

package/lib/public/index.d.ts

@@ -1,4 +1,4 @@
-import Database from "#Database";
-declare const _default: (config: typeof Database.config) => Database;
+import MySQL from "#MySQL";
+declare const _default: (config: typeof MySQL.config) => MySQL;
 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 MySQL from "#MySQL";
+export default (config) => new MySQL(config);
 //# sourceMappingURL=index.js.map

package/package.json

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

package/lib/private/Database.d.ts

@@ -1,47 +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">, 3306>;
-    username: import("pema").OptionalType<import("pema/string").StringType>;
-}>;
-export default class MySQLDatabase extends Database {
-    #private;
-    static config: typeof schema.input;
-    constructor(config?: typeof schema.input);
-    get typemap(): TypeMap<Dict>;
-    formatBinds(binds: Dict): 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<number>;
-    delete(as: As, args: {
-        criteria: DataDict;
-    }): Promise<number>;
-}
-export {};
-//# sourceMappingURL=Database.d.ts.map

package/lib/private/Database.js

@@ -1,148 +0,0 @@
-import typemap from "#typemap";
-import Database from "@primate/core/Database";
-import assert from "@rcompat/assert";
-import mysql from "mysql2/promise";
-import pema from "pema";
-import string from "pema/string";
-import uint from "pema/uint";
-const schema = pema({
-    database: string,
-    host: string.default("localhost"),
-    password: string.optional(),
-    port: uint.port().default(3306),
-    username: string.optional(),
-});
-export default class MySQLDatabase extends Database {
-    #factory;
-    #client;
-    static config;
-    constructor(config) {
-        super(":");
-        const parsed = schema.parse(config);
-        this.#factory = () => mysql.createPool({
-            host: parsed.host,
-            port: parsed.port,
-            database: parsed.database,
-            user: parsed.username,
-            password: parsed.password,
-            connectionLimit: 10,
-            queueLimit: 0,
-            keepAliveInitialDelay: 0,
-            enableKeepAlive: true,
-            waitForConnections: true,
-            namedPlaceholders: true,
-            bigNumberStrings: true,
-            supportBigNumbers: true,
-        });
-    }
-    get typemap() {
-        return typemap;
-    }
-    #get() {
-        if (this.#client === undefined) {
-            this.#client = this.#factory();
-        }
-        return this.#client;
-    }
-    formatBinds(binds) {
-        return Object.fromEntries(Object.entries(binds).map(([k, v]) => [k.replace(/^[:$]/, ""), v]));
-    }
-    async close() {
-        await this.#get().end();
-    }
-    async #with(executor) {
-        const connection = await this.#get().getConnection();
-        try {
-            return await executor(connection);
-        }
-        finally {
-            connection.release();
-        }
-    }
-    async #new(name, store) {
-        const body = Object.entries(store)
-            .map(([key, value]) => `${this.ident(key)} ${this.column(value.datatype)}`)
-            .join(",");
-        const query = `CREATE TABLE IF NOT EXISTS ${this.ident(name)} (${body})`;
-        await this.#with(async (connection) => {
-            await connection.query(query);
-        });
-    }
-    async #drop(name) {
-        const query = `DROP TABLE IF EXISTS ${this.ident(name)}`;
-        await this.#with(async (connection) => {
-            await connection.query(query);
-        });
-    }
-    get schema() {
-        return {
-            create: this.#new.bind(this),
-            delete: this.#drop.bind(this),
-        };
-    }
-    async create(as, args) {
-        const keys = Object.keys(args.record);
-        const columns = keys.map(k => this.ident(k));
-        const values = keys.map(key => `:${key}`).join(",");
-        const payload = `(${columns.join(",")}) VALUES (${values})`;
-        const query = `INSERT INTO ${this.table(as)} ${payload};`;
-        const binds = await this.bind(as.types, args.record);
-        return this.#with(async (connection) => {
-            const [{ insertId }] = await connection.query(query, binds);
-            return this.unbind(as.types, { ...args.record, id: insertId });
-        });
-    }
-    async read(as, args) {
-        const where = this.toWhere(as.types, args.criteria);
-        const binds = await this.bindCriteria(as.types, args.criteria);
-        if (args.count === true) {
-            return this.#with(async (connection) => {
-                const query = `SELECT COUNT(*) AS n FROM ${this.table(as)} ${where}`;
-                const [[{ n }]] = await connection.query(query, binds);
-                return Number(n);
-            });
-        }
-        const select = this.toSelect(as.types, args.fields);
-        const sort = this.toSort(as.types, args.sort);
-        const limit = this.toLimit(args.limit);
-        const query = `SELECT ${select}
-      FROM ${this.table(as)} ${where}${sort}${limit};`;
-        return this.#with(async (connection) => {
-            const [records] = await connection.query(query, binds);
-            return records.map(record => this.unbind(as.types, record));
-        });
-    }
-    async update(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
-        const where = this.toWhere(as.types, args.criteria);
-        const criteria = await this.bindCriteria(as.types, args.criteria);
-        const { set, binds: set_binds } = await this.toSet(as.types, args.changes);
-        const binds = { ...criteria, ...set_binds };
-        const query = `
-      UPDATE ${this.table(as)}
-      ${set}
-      WHERE id IN (
-        SELECT id FROM (
-          SELECT id FROM ${this.table(as)}
-          ${where}
-        ) AS to_update
-      );
-    `;
-        return this.#with(async (connection) => {
-            const [{ affectedRows }] = await connection.query(query, binds);
-            return affectedRows;
-        });
-    }
-    async delete(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "delete: no criteria");
-        const where = this.toWhere(as.types, args.criteria);
-        const binds = await this.bindCriteria(as.types, args.criteria);
-        const query = `DELETE FROM ${this.table(as)} ${where}`;
-        return this.#with(async (connection) => {
-            const [{ affectedRows }] = await connection.query(query, binds);
-            return affectedRows;
-        });
-    }
-    ;
-}
-//# sourceMappingURL=Database.js.map