@primate/mysql 0.6.0 → 0.8.0

package/lib/private/MySQL.d.ts

@@ -1,24 +1,29 @@
-import type { As, DataDict, DB, Schema, 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";
-declare const schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+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 port: import("pema").DefaultType<import("pema").UintType<"u32", undefined>, 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<undefined>, true>;
+}>, undefined, {
     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[];
@@ -45,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

@@ -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 !== undefined ? `${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"}`;
     });
@@ -78,6 +78,7 @@ const schema = p({
     database: p.string,
     password: p.string.optional(),
     username: p.string.optional(),
+    jsonStrings: p.boolean.default(true),
 });
 export default class MySQL {
     static config;
@@ -96,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;
@@ -208,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}`);
@@ -229,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);
                     }
@@ -340,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,
         ];
     }
@@ -424,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])];
@@ -437,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 = `
@@ -524,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/mysql",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "MySQL databases for Primate",
   "homepage": "https://primate.run/docs/database/mysql",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,17 +17,17 @@
     "!/**/*.spec.*"
   ],
   "devDependencies": {
-    "@rcompat/type": "^0.11.1"
+    "@rcompat/type": "^0.17.0"
   },
   "dependencies": {
-    "@rcompat/assert": "^0.8.1",
-    "@rcompat/is": "^0.6.1",
-    "mysql2": "^3.20.0",
-    "@primate/core": "^0.6.0",
-    "pema": "0.6.0"
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/is": "^0.11.0",
+    "mysql2": "^3.22.4",
+    "@primate/core": "^0.8.0",
+    "pema": "0.8.0"
   },
   "peerDependencies": {
-    "primate": "^0.37.0"
+    "primate": "^0.39.0"
   },
   "imports": {
     "#*": {
@@ -42,9 +42,13 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && tsgo",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
-    "test": "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"
   }
 }