@primate/mysql 0.5.0 → 0.7.0

package/lib/private/ColumnTypes.d.ts

@@ -20,6 +20,8 @@ type ColumnTypes = Validate<{
     "TIME": string;
     TINYINT: number;
     "TINYINT UNSIGNED": number;
+    JSON: string;
+    "BINARY(16)": Uint8Array<ArrayBuffer>;
 }>;
 export type { ColumnTypes as default };
 //# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/MySQL.d.ts

@@ -1,28 +1,35 @@
-import type { As, DataDict, DB, Sort, With } from "@primate/core/db";
+import type { As, DataDict, ExtractPlaceholders, Schema, Sort, SQLDB, With, CheckPlaceholders } 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>;
+import type { Pool } from "mysql2/promise";
+import type { ObjectType, Parsed } from "pema";
+declare const schema: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+    readonly port: import("pema").DefaultType<import("pema").UintType<"u32">, 3306>;
+    readonly database: import("pema").StringType;
+    readonly password: import("pema").OptionalType<import("pema").StringType>;
+    readonly username: import("pema").OptionalType<import("pema").StringType>;
+    readonly jsonStrings: import("pema").DefaultType<import("pema").BooleanType, true>;
+}>, {
+    host: string;
+    port: number;
+    database: string;
+    password: string | undefined;
+    username: string | undefined;
+    jsonStrings: boolean;
 }>;
-export default class MySQL implements DB {
+export default class MySQL implements SQLDB<Pool> {
     #private;
     static config: typeof schema.input;
     constructor(config?: typeof schema.input, options?: {
         debug?: boolean;
     });
+    get client(): Pool;
     get explain(): Dict<{
         query: string;
         plans: string[];
     }>;
     close(): Promise<void>;
-    get schema(): {
-        create: (as: As, store: StoreSchema) => Promise<void>;
-        delete: (table: string) => Promise<void>;
-    };
+    get schema(): Schema;
     create<O extends Dict>(as: As, record: Dict): Promise<O>;
     read(as: As, args: {
         count: true;
@@ -43,6 +50,13 @@ export default class MySQL implements DB {
     delete(as: As, args: {
         where: DataDict;
     }): Promise<number>;
+    sql<Q extends string, I extends ObjectType<{
+        [K in ExtractPlaceholders<Q>]: Parsed<unknown>;
+    }> | undefined, O extends Parsed<unknown> | undefined>(options: {
+        input?: I extends ObjectType<any> ? CheckPlaceholders<I, Q> : I;
+        query: Q;
+        output?: O;
+    }): (args: I extends ObjectType<any> ? I["infer"] : void) => Promise<O extends Parsed<unknown> ? O["infer"] : void>;
 }
 export {};
 //# sourceMappingURL=MySQL.d.ts.map

package/lib/private/MySQL.js

@@ -1,6 +1,6 @@
 import typemap from "#typemap";
-import common from "@primate/core/db";
-import E from "@primate/core/db/error";
+import base from "@primate/core/db";
+import E from "@primate/core/db/errors";
 import sql from "@primate/core/db/sql";
 import assert from "@rcompat/assert";
 import is from "@rcompat/is";
@@ -15,14 +15,14 @@ function is_bigint_key(k) {
     return k === "u64" || k === "u128" || k === "i64" || k === "i128";
 }
 function order_by(types, sort, alias) {
-    if (sort === undefined)
+    if (is.undefined(sort))
         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 base = is.defined(alias) ? `${alias}.${quoted}` : quoted;
         const expression = is_bigint_key(types[k]) ? bigint_cast(base) : base;
         return `${expression} ${dir.toLowerCase() === "desc" ? "DESC" : "ASC"}`;
     });
@@ -42,12 +42,43 @@ function unbind_value(key, value) {
 function unbind(types, row) {
     return sql.unbind(types, row, unbind_value);
 }
+function columns_to_types(data_t, column_t) {
+    const unsigned = column_t.includes("unsigned");
+    if (data_t === "varchar")
+        return ["string", "url"];
+    if (data_t === "text")
+        return ["string", "url", "time"];
+    if (data_t === "binary" && column_t.includes("(16)"))
+        return base.UUID_TYPES;
+    if (data_t === "smallint")
+        return unsigned ? ["u16"] : ["i16"];
+    if (data_t === "int")
+        return unsigned ? ["u32"] : ["i32"];
+    if (data_t === "bigint")
+        return unsigned ? ["u64"] : ["i64"];
+    if (data_t === "decimal")
+        return ["u128", "i128"];
+    if (data_t === "double")
+        return ["f32", "f64"];
+    if (data_t === "datetime")
+        return ["datetime"];
+    if (data_t === "tinyint" && column_t === "tinyint(1)")
+        return ["boolean"];
+    if (data_t === "tinyint")
+        return unsigned ? ["u8"] : ["i8", "boolean"];
+    if (data_t === "blob")
+        return ["blob"];
+    if (data_t === "json")
+        return ["json"];
+    return [];
+}
 const schema = p({
-    database: p.string,
     host: p.string.default("localhost"),
-    password: p.string.optional(),
     port: p.uint.port().default(3306),
+    database: p.string,
+    password: p.string.optional(),
     username: p.string.optional(),
+    jsonStrings: p.boolean.default(true),
 });
 export default class MySQL {
     static config;
@@ -66,12 +97,16 @@ export default class MySQL {
             namedPlaceholders: true,
             bigNumberStrings: true,
             supportBigNumbers: true,
+            jsonStrings: parsed.jsonStrings,
         });
         this.#debug = options?.debug ?? false;
     }
     get #db() {
         return this.#client ??= this.#factory();
     }
+    get client() {
+        return this.#db;
+    }
     async #sql(query, params) {
         const [rows] = await this.#db.query(query, params);
         return rows;
@@ -94,26 +129,63 @@ export default class MySQL {
     }
     get schema() {
         return {
-            create: async (as, store) => {
+            create: async (table, pk, types) => {
                 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" : "";
+                for (const [key, value] of Object.entries(types)) {
+                    const type = get_column(value);
+                    if (key === pk.name) {
+                        const is_int = base.INT_TYPES.includes(value);
+                        const auto = pk.generate && is_int ? " AUTO_INCREMENT" : "";
                         // 36 is UUID length
-                        const pk_type = value.datatype === "string" ? "VARCHAR(36)" : type;
+                        const pk_type = value === "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})`);
+                await this.#sql(Q `CREATE TABLE IF NOT EXISTS ${table} (${columns})`);
             },
             delete: async (table) => {
                 await this.#sql(Q `DROP TABLE IF EXISTS ${table}`);
             },
+            introspect: async (table) => {
+                const rows = await this.#sql(`
+          SELECT COLUMN_NAME, DATA_TYPE, COLUMN_TYPE
+          FROM information_schema.COLUMNS
+          WHERE TABLE_SCHEMA = DATABASE()
+          AND TABLE_NAME = :name
+        `, { name: table });
+                if (rows.length === 0)
+                    return null;
+                const result = {};
+                for (const row of rows) {
+                    const candidates = columns_to_types(row.DATA_TYPE, row.COLUMN_TYPE);
+                    if (candidates.length > 0)
+                        result[row.COLUMN_NAME] = candidates;
+                }
+                return result;
+            },
+            alter: async (table, diff) => {
+                const existing = await this.schema.introspect(table);
+                if (existing === null)
+                    throw E.table_not_found(table);
+                for (const [from, to] of diff.rename) {
+                    await this.#sql(Q `
+            ALTER TABLE ${table}
+            RENAME COLUMN ${[sql.quote(from)]} TO ${[sql.quote(to)]}`);
+                }
+                const parts = [];
+                for (const field of diff.drop) {
+                    parts.push(`DROP COLUMN ${sql.quote(field)}`);
+                }
+                for (const [field, type] of Object.entries(diff.add)) {
+                    parts.push(`ADD COLUMN ${sql.quote(field)} ${get_column(type)}`);
+                }
+                if (parts.length > 0) {
+                    await this.#sql(Q `ALTER TABLE ${table} ${[parts.join(", ")]}`);
+                }
+            },
         };
     }
     async #where(as, where) {
@@ -141,7 +213,9 @@ export default class MySQL {
                     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);
+                    if (op !== "$in") {
+                        binds[bind_key] = await bind_value(datatype, op_value);
+                    }
                     switch (op) {
                         case "$like":
                             parts.push(`${quoted} LIKE BINARY ${ph}`);
@@ -162,6 +236,19 @@ export default class MySQL {
                             parts.push(`${lhs} ${sql_op} ${rhs}`);
                             break;
                         }
+                        case "$in": {
+                            const array = op_value;
+                            const placeholders = [];
+                            for (let i = 0; i < array.length; i++) {
+                                const key = `${sql.bindKey(field, `in${i}`)}`;
+                                binds[key] = await bind_value(datatype, array[i]);
+                                const ph = `${BIND_BY}${key}`;
+                                placeholders.push(is_bigint_key(datatype) ? bigint_cast(ph) : ph);
+                            }
+                            const lhs = is_bigint_key(datatype) ? bigint_cast(quoted) : quoted;
+                            parts.push(`${lhs} IN (${placeholders.join(", ")})`);
+                            break;
+                        }
                         default:
                             throw E.operator_unknown(field, op);
                     }
@@ -193,9 +280,9 @@ export default class MySQL {
         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)) {
+        if (base.is_uuid_type(type))
+            return base.generate_uuid(type);
+        if (base.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);
@@ -235,7 +322,7 @@ export default class MySQL {
             throw E.pk_required(pk);
         const type = as.types[pk];
         // integer types, use AUTO_INCREMENT
-        if (!common.BIGINT_STRING_TYPES.includes(type) && type !== "string") {
+        if (!base.BIGINT_STRING_TYPES.includes(type) && !base.is_uuid_type(type)) {
             const [keys, values] = this.#create(record);
             const query = keys.length > 0
                 ? Q `INSERT INTO ${table} (${keys}) VALUES (${values})`
@@ -257,7 +344,7 @@ export default class MySQL {
         this.#explain = {};
         if (args.count === true)
             return this.#count(as, args.where);
-        if (common.withed(args)) {
+        if (base.withed(args)) {
             return sql.joinable(as, args.with)
                 ? this.#read_joined(as, args)
                 : this.#read_phased(as, args);
@@ -273,15 +360,16 @@ export default class MySQL {
         return Number(rows[0]?.n ?? 0);
     }
     async #base_query(as, args) {
-        const SELECT = args.fields === undefined
+        const SELECT = is.undefined(args.fields)
             ? "*"
             : 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 LIMIT = is.defined(args.limit) ? ` LIMIT ${args.limit}` : "";
+        const OFFSET = is.defined(args.offset) ? ` OFFSET ${args.offset}` : "";
         const table = sql.quote(as.table);
         return [
-            `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}`,
+            `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}${OFFSET}`,
             binds,
         ];
     }
@@ -292,9 +380,9 @@ export default class MySQL {
         return rows.map(r => unbind(as.types, r));
     }
     async #read_phased(as, args) {
-        const fields = common.expand(as, args.fields, args.with);
+        const fields = base.expand(as, args.fields, args.with);
         const rows = await this.#read(as, { ...args, fields });
-        const out = rows.map(row => common.project(row, args.fields));
+        const out = rows.map(row => base.project(row, args.fields));
         for (const [table, relation] of Object.entries(args.with)) {
             await this.#attach_relation(as, { rows, out, table, relation });
         }
@@ -330,8 +418,8 @@ export default class MySQL {
             }
             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;
+                ? rows.map(r => base.project(r, relation.fields))
+                : rows[0] ? base.project(rows[0], relation.fields) : null;
         }
     }
     async #load_related(args) {
@@ -357,7 +445,7 @@ export default class MySQL {
             : [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
+        const fields = is.defined(args.fields) && is.uint(args.fields.length)
             ? args.fields
             : all_columns;
         const select_fields = [...new Set([...fields, args.by])];
@@ -370,7 +458,7 @@ export default class MySQL {
             : ` ORDER BY ${base_order}`;
         const table = sql.quote(args.as.table);
         let query;
-        if (per_parent !== undefined) {
+        if (is.defined(per_parent)) {
             const partition = numeric ? cast : Q `${args.by}`;
             const rn_order = user_order ? ` ORDER BY ${user_order}` : "";
             query = `
@@ -416,13 +504,13 @@ export default class MySQL {
         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 fields = base.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)
+                    ? base.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}`);
@@ -457,5 +545,32 @@ export default class MySQL {
         const result = await this.#execute(query, binds);
         return result.affectedRows;
     }
+    sql(options) {
+        if (is.defined(options.input)) {
+            const placeholders = new Set([...options.query.matchAll(/:(\w+)/g)].map(m => m[1]));
+            const input_keys = new Set(Object.keys(options.input.properties));
+            for (const key of input_keys) {
+                if (!placeholders.has(key))
+                    throw E.sql_placeholder_missing(key);
+            }
+            for (const key of placeholders) {
+                if (!input_keys.has(key))
+                    throw E.sql_input_missing(key);
+            }
+        }
+        return async (args) => {
+            const input = is.defined(options.input)
+                ? options.input.parse(args)
+                : undefined;
+            const binds = is.defined(input)
+                ? await this.#create_params(Object.fromEntries(Object.entries(options.input.properties)
+                    .map(([k, v]) => [k, v.datatype])), input)
+                : {};
+            const rows = await this.#sql(options.query, binds);
+            return (is.defined(options.output)
+                ? options.output.parse(rows)
+                : undefined);
+        };
+    }
 }
 //# sourceMappingURL=MySQL.js.map

package/lib/private/typemap.js

@@ -12,6 +12,18 @@ function number(column) {
         unbind: (value) => Number(value),
     };
 }
+function uuid_to_bin(uuid) {
+    return Uint8Array.fromHex(uuid.replace(/-/g, ""));
+}
+function bin_to_uuid(buf) {
+    const hex = buf.toHex();
+    const a = hex.slice(0, 8);
+    const b = hex.slice(8, 12);
+    const c = hex.slice(12, 16);
+    const d = hex.slice(16, 20);
+    const e = hex.slice(20);
+    return `${a}-${b}-${c}-${d}-${e}`;
+}
 const typemap = {
     blob: {
         async bind(value) {
@@ -55,16 +67,15 @@ const typemap = {
         },
     },
     i8: number("TINYINT"),
-    /*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);
-      },
-    },*/
+    json: {
+        bind(value) {
+            return JSON.stringify(value);
+        },
+        column: "JSON",
+        unbind(value) {
+            return JSON.parse(value);
+        },
+    },
     string: identity("TEXT"),
     time: identity("TEXT"),
     u128: {
@@ -97,6 +108,21 @@ const typemap = {
             return new URL(value);
         },
     },
+    uuid: {
+        bind: uuid_to_bin,
+        column: "BINARY(16)",
+        unbind: bin_to_uuid,
+    },
+    uuid_v4: {
+        bind: uuid_to_bin,
+        column: "BINARY(16)",
+        unbind: bin_to_uuid,
+    },
+    uuid_v7: {
+        bind: uuid_to_bin,
+        column: "BINARY(16)",
+        unbind: bin_to_uuid,
+    },
 };
 export default typemap;
 //# sourceMappingURL=typemap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/mysql",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "MySQL databases for Primate",
   "homepage": "https://primate.run/docs/database/mysql",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,27 +17,27 @@
     "!/**/*.spec.*"
   ],
   "devDependencies": {
-    "@rcompat/type": "^0.9.0"
+    "@rcompat/type": "^0.17.0"
   },
   "dependencies": {
-    "@rcompat/assert": "^0.6.0",
-    "@rcompat/is": "^0.4.2",
-    "mysql2": "^3.17.1",
-    "@primate/core": "^0.5.0",
-    "pema": "0.5.0"
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/is": "^0.11.0",
+    "mysql2": "^3.22.3",
+    "@primate/core": "^0.7.0",
+    "pema": "0.7.0"
   },
   "peerDependencies": {
-    "primate": "^0.36.0"
+    "primate": "^0.38.0"
   },
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
-      "apekit": "./src/public/index.ts",
+      "@primate/source": "./src/public/index.ts",
       "default": "./lib/public/index.js"
     }
   },
@@ -45,6 +45,10 @@
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
-    "test": "npm run build && npx proby"
+    "mysql": "scripts/mysql.sh",
+    "mariadb": "scripts/mariadb.sh",
+    "test:mysql": "npm run mysql && npx proby",
+    "test:mariadb": "npm run mariadb && npx proby",
+    "test": "npm run test:mysql"
   }
 }