@primate/mysql 0.5.0 → 0.6.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,12 +1,17 @@
-import type { As, DataDict, DB, Sort, With } from "@primate/core/db";
+import type { As, DataDict, DB, Schema, 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>;
+declare const schema: import("pema").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>;
+}>, {
+    host: string;
+    port: number;
+    database: string;
+    password: string | undefined;
+    username: string | undefined;
 }>;
 export default class MySQL implements DB {
     #private;
@@ -19,10 +24,7 @@ export default class MySQL implements DB {
         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;

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";
@@ -22,7 +22,7 @@ function order_by(types, sort, alias) {
         return "";
     const parts = entries.map(([k, dir]) => {
         const quoted = sql.quote(k);
-        const base = alias ? `${alias}.${quoted}` : quoted;
+        const base = alias !== undefined ? `${alias}.${quoted}` : quoted;
         const expression = is_bigint_key(types[k]) ? bigint_cast(base) : base;
         return `${expression} ${dir.toLowerCase() === "desc" ? "DESC" : "ASC"}`;
     });
@@ -42,11 +42,41 @@ 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(),
 });
 export default class MySQL {
@@ -94,26 +124,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) {
@@ -193,9 +260,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 +302,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 +324,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);
@@ -292,9 +359,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 +397,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) {
@@ -416,13 +483,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}`);

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.6.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.11.1"
   },
   "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.8.1",
+    "@rcompat/is": "^0.6.1",
+    "mysql2": "^3.20.0",
+    "@primate/core": "^0.6.0",
+    "pema": "0.6.0"
   },
   "peerDependencies": {
-    "primate": "^0.36.0"
+    "primate": "^0.37.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,6 @@
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
-    "test": "npm run build && npx proby"
+    "test": "npx proby"
   }
 }