@jskit-ai/database-runtime-mysql 0.1.126 → 0.1.128

package/package.descriptor.mjs

@@ -13,7 +13,7 @@ const CI_DATABASE = Object.freeze({
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/database-runtime-mysql",
-  version: "0.1.126",
+  version: "0.1.128",
   kind: "runtime",
   options: {
     "db-host": {
@@ -133,7 +133,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/database-runtime": "0.1.127",
+        "@jskit-ai/database-runtime": "0.1.129",
         "mysql2": "^3.11.2"
       },
       dev: {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/database-runtime-mysql",
-  "version": "0.1.126",
+  "version": "0.1.128",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -12,7 +12,7 @@
     "./shared/dialect": "./src/shared/dialect.js"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime": "0.1.127",
-    "@jskit-ai/kernel": "0.1.128"
+    "@jskit-ai/database-runtime": "0.1.129",
+    "@jskit-ai/kernel": "0.1.130"
   }
 }

package/src/shared/introspectCrudTable.js

@@ -2,7 +2,11 @@ import { normalizeText } from "@jskit-ai/database-runtime/shared";
 import { toCamelCase } from "@jskit-ai/kernel/shared/support/stringCase";
 
 const BOOLEAN_TINYINT_PATTERN = /^tinyint\(1\)/;
+const CURRENT_TIMESTAMP_EXPRESSION_PATTERN = /^current_timestamp(?:\((\d*)\))?$/i;
+const ON_UPDATE_CURRENT_TIMESTAMP_PATTERN =
+  /(?:^|\s)on\s+update\s+(current_timestamp(?:\((\d*)\))?)(?:\s|$)/i;
 const TABLE_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
+const TEMPORAL_DATA_TYPES = new Set(["datetime", "timestamp"]);
 
 function requireKnexRaw(knex) {
   if (!knex || typeof knex.raw !== "function") {
@@ -77,6 +81,31 @@ function normalizeColumnDefault(value) {
   return value;
 }
 
+function normalizeCurrentTimestampExpression(value) {
+  const match = normalizeText(value).match(CURRENT_TIMESTAMP_EXPRESSION_PATTERN);
+  if (!match) {
+    return null;
+  }
+
+  const precision =
+    match[1] == null || match[1] === ""
+      ? null
+      : Number.parseInt(match[1], 10);
+  if (precision != null && (!Number.isInteger(precision) || precision < 0 || precision > 6)) {
+    return null;
+  }
+
+  return Object.freeze({
+    kind: "current_timestamp",
+    precision
+  });
+}
+
+function normalizeOnUpdateExpression(value) {
+  const match = normalizeText(value).match(ON_UPDATE_CURRENT_TIMESTAMP_PATTERN);
+  return match ? normalizeCurrentTimestampExpression(match[1]) : null;
+}
+
 function parseEnumValues(columnType = "") {
   const source = normalizeText(columnType);
   if (!source.toLowerCase().startsWith("enum(") || !source.endsWith(")")) {
@@ -180,6 +209,7 @@ function normalizeColumn(row = {}) {
   const autoIncrement = extra.includes("auto_increment");
   const unsigned = columnTypeLower.includes("unsigned");
   const enumValues = parseEnumValues(columnType);
+  const supportsTemporalExpressions = TEMPORAL_DATA_TYPES.has(dataType);
 
   const normalized = Object.freeze({
     name,
@@ -194,8 +224,14 @@ function normalizeColumn(row = {}) {
     }),
     nullable,
     defaultValue,
+    defaultExpression: supportsTemporalExpressions
+      ? normalizeCurrentTimestampExpression(defaultValue)
+      : null,
     hasDefault,
     autoIncrement,
+    onUpdateExpression: supportsTemporalExpressions
+      ? normalizeOnUpdateExpression(extra)
+      : null,
     unsigned,
     maxLength: toNullableNumber(row.characterMaximumLength ?? row.character_maximum_length),
     numericPrecision: toNullableNumber(row.numericPrecision ?? row.numeric_precision),
@@ -218,6 +254,36 @@ function normalizePrimaryKeyColumns(rows = []) {
   );
 }
 
+function normalizePrimaryKeyColumnsByTable(rows = []) {
+  const grouped = new Map();
+
+  for (const row of Array.isArray(rows) ? rows : []) {
+    const tableName = normalizeText(row.tableName || row.table_name);
+    const columnName = normalizeText(row.columnName || row.column_name);
+    if (!tableName || !columnName) {
+      continue;
+    }
+
+    const columns = grouped.get(tableName) || [];
+    columns.push({
+      name: columnName,
+      order: toNullableNumber(row.ordinalPosition ?? row.ordinal_position) || 0
+    });
+    grouped.set(tableName, columns);
+  }
+
+  return new Map(
+    [...grouped.entries()].map(([tableName, columns]) => [
+      tableName,
+      Object.freeze(
+        columns
+          .sort((left, right) => left.order - right.order)
+          .map((column) => column.name)
+      )
+    ])
+  );
+}
+
 function normalizeIndexes(rows = []) {
   const byName = new Map();
 
@@ -369,6 +435,32 @@ function requirePrimaryKeyContainsId(primaryKeyColumns, idColumn) {
   }
 }
 
+function requireSupportedForeignKeys(foreignKeys, primaryKeyColumnsByTable) {
+  for (const foreignKey of foreignKeys) {
+    const columns = Array.isArray(foreignKey?.columns) ? foreignKey.columns : [];
+    if (columns.length !== 1) {
+      throw new Error(
+        `CRUD generation supports only single-column foreign keys. Constraint "${foreignKey.name}" has ${columns.length} columns.`
+      );
+    }
+
+    const targetTable = normalizeText(foreignKey.referencedTableName);
+    const targetColumn = normalizeText(columns[0]?.referencedName);
+    const targetPrimaryKey = primaryKeyColumnsByTable.get(targetTable) || [];
+    if (targetPrimaryKey.length !== 1) {
+      const actual = targetPrimaryKey.length > 0 ? targetPrimaryKey.join(", ") : "none";
+      throw new Error(
+        `CRUD foreign key "${foreignKey.name}" targets table "${targetTable}", whose primary key is not single-column (found: ${actual}).`
+      );
+    }
+    if (targetColumn !== targetPrimaryKey[0]) {
+      throw new Error(
+        `CRUD foreign key "${foreignKey.name}" must target the primary key "${targetTable}.${targetPrimaryKey[0]}", not "${targetTable}.${targetColumn}".`
+      );
+    }
+  }
+}
+
 async function introspectCrudTableSnapshot(knex, { tableName = "", idColumn = "id" } = {}) {
   requireKnexRaw(knex);
   const resolvedTableName = requireTableName(tableName);
@@ -482,6 +574,22 @@ async function introspectCrudTableSnapshot(knex, { tableName = "", idColumn = "i
     )
   );
 
+  const schemaPrimaryKeyRows = normalizeRows(
+    await knex.raw(
+      `
+        SELECT
+          s.table_name AS tableName,
+          s.column_name AS columnName,
+          s.seq_in_index AS ordinalPosition
+        FROM information_schema.statistics s
+        WHERE s.table_schema = ?
+          AND s.index_name = 'PRIMARY'
+        ORDER BY s.table_name ASC, s.seq_in_index ASC
+      `,
+      [schemaName]
+    )
+  );
+
   const checkConstraintRows = normalizeRows(
     await knex.raw(
       `
@@ -505,6 +613,11 @@ async function introspectCrudTableSnapshot(knex, { tableName = "", idColumn = "i
   const resolvedIdColumn = requireIdColumn(columns, idColumn);
   const primaryKeyColumns = normalizePrimaryKeyColumns(primaryRows);
   requirePrimaryKeyContainsId(primaryKeyColumns, resolvedIdColumn);
+  const foreignKeys = normalizeForeignKeys(foreignKeyRows);
+  requireSupportedForeignKeys(
+    foreignKeys,
+    normalizePrimaryKeyColumnsByTable(schemaPrimaryKeyRows)
+  );
   const firstTableRow = Array.isArray(tableRows) ? tableRows[0] : null;
 
   const snapshot = Object.freeze({
@@ -518,7 +631,7 @@ async function introspectCrudTableSnapshot(knex, { tableName = "", idColumn = "i
     hasUserIdColumn: columns.some((column) => column.name === "user_id"),
     columns,
     indexes: normalizeIndexes(indexRows),
-    foreignKeys: normalizeForeignKeys(foreignKeyRows),
+    foreignKeys,
     checkConstraints: normalizeCheckConstraints(checkConstraintRows)
   });
 

package/test/introspectCrudTable.test.js

@@ -10,6 +10,7 @@ function createKnexRawDouble({
   primaryKeyColumns = [],
   indexes = [],
   foreignKeys = [],
+  primaryKeysByTable = {},
   checkConstraints = []
 } = {}) {
   const calls = [];
@@ -37,6 +38,21 @@ function createKnexRawDouble({
       if (normalizedSql.includes("from information_schema.table_constraints")) {
         return [[...primaryKeyColumns], []];
       }
+      if (
+        normalizedSql.includes("from information_schema.statistics") &&
+        normalizedSql.includes("s.index_name = 'primary'")
+      ) {
+        return [
+          Object.entries(primaryKeysByTable).flatMap(([tableName, columnNames]) =>
+            columnNames.map((columnName, index) => ({
+              tableName,
+              columnName,
+              ordinalPosition: index + 1
+            }))
+          ),
+          []
+        ];
+      }
       if (normalizedSql.includes("from information_schema.statistics")) {
         return [[...indexes], []];
       }
@@ -150,16 +166,16 @@ test("introspectCrudTableSnapshot maps MySQL table metadata to normalized snapsh
       {
         columnName: "updated_at",
         dataType: "datetime",
-        columnType: "datetime",
+        columnType: "datetime(3)",
         isNullable: "NO",
-        columnDefault: "CURRENT_TIMESTAMP",
-        extra: "",
+        columnDefault: "CURRENT_TIMESTAMP(3)",
+        extra: "DEFAULT_GENERATED on update CURRENT_TIMESTAMP(3)",
         characterMaximumLength: null,
         characterSetName: null,
         collationName: null,
         numericPrecision: null,
         numericScale: null,
-        datetimePrecision: 0,
+        datetimePrecision: 3,
         ordinalPosition: 7
       },
       {
@@ -204,6 +220,10 @@ test("introspectCrudTableSnapshot maps MySQL table metadata to normalized snapsh
         deleteRule: "SET NULL"
       }
     ],
+    primaryKeysByTable: {
+      contacts: ["id"],
+      workspaces: ["id"]
+    },
     checkConstraints: [
       {
         constraintName: "settings_json",
@@ -249,6 +269,16 @@ test("introspectCrudTableSnapshot maps MySQL table metadata to normalized snapsh
   assert.equal(settingsJson.characterSetName, "utf8mb4");
   assert.equal(settingsJson.collationName, "utf8mb4_bin");
 
+  const updatedAt = snapshot.columns.find((column) => column.name === "updated_at");
+  assert.deepEqual(updatedAt.defaultExpression, {
+    kind: "current_timestamp",
+    precision: 3
+  });
+  assert.deepEqual(updatedAt.onUpdateExpression, {
+    kind: "current_timestamp",
+    precision: 3
+  });
+
   assert.deepEqual(snapshot.indexes, [
     {
       name: "idx_contacts_first_name",
@@ -355,3 +385,184 @@ test("introspectCrudTableSnapshot rejects when primary key does not include id c
     /Primary key must include id column "id"/
   );
 });
+
+test("introspectCrudTableSnapshot classifies only allowlisted temporal defaults as SQL expressions", async () => {
+  const { knex } = createKnexRawDouble({
+    columns: [
+      ...validIdColumns(),
+      {
+        columnName: "label",
+        dataType: "varchar",
+        columnType: "varchar(190)",
+        isNullable: "NO",
+        columnDefault: "CURRENT_TIMESTAMP(3)",
+        extra: "",
+        characterMaximumLength: 190,
+        characterSetName: "utf8mb4",
+        collationName: "utf8mb4_general_ci",
+        ordinalPosition: 2
+      },
+      {
+        columnName: "created_at",
+        dataType: "datetime",
+        columnType: "datetime",
+        isNullable: "NO",
+        columnDefault: "CURRENT_TIMESTAMP()",
+        extra: "",
+        datetimePrecision: 0,
+        ordinalPosition: 3
+      }
+    ],
+    primaryKeyColumns: [{ columnName: "id" }]
+  });
+
+  const snapshot = await introspectCrudTableSnapshot(knex, {
+    tableName: "labels"
+  });
+  const label = snapshot.columns.find((column) => column.name === "label");
+
+  assert.equal(label.defaultValue, "CURRENT_TIMESTAMP(3)");
+  assert.equal(label.defaultExpression, null);
+  assert.equal(label.onUpdateExpression, null);
+  assert.deepEqual(
+    snapshot.columns.find((column) => column.name === "created_at").defaultExpression,
+    {
+      kind: "current_timestamp",
+      precision: null
+    }
+  );
+});
+
+function validIdColumns(extraColumns = []) {
+  return [
+    {
+      columnName: "id",
+      dataType: "bigint",
+      columnType: "bigint unsigned",
+      isNullable: "NO",
+      columnDefault: null,
+      extra: "auto_increment",
+      numericPrecision: 20,
+      numericScale: 0,
+      ordinalPosition: 1
+    },
+    ...extraColumns
+  ];
+}
+
+test("introspectCrudTableSnapshot rejects composite foreign keys", async () => {
+  const { knex } = createKnexRawDouble({
+    columns: validIdColumns([
+      {
+        columnName: "workspace_id",
+        dataType: "bigint",
+        columnType: "bigint unsigned",
+        isNullable: "NO",
+        extra: "",
+        ordinalPosition: 2
+      },
+      {
+        columnName: "parent_id",
+        dataType: "bigint",
+        columnType: "bigint unsigned",
+        isNullable: "NO",
+        extra: "",
+        ordinalPosition: 3
+      }
+    ]),
+    primaryKeyColumns: [{ columnName: "id" }],
+    foreignKeys: [
+      {
+        constraintName: "items_parent_foreign",
+        columnName: "workspace_id",
+        referencedTableName: "parents",
+        referencedColumnName: "workspace_id",
+        ordinalPosition: 1
+      },
+      {
+        constraintName: "items_parent_foreign",
+        columnName: "parent_id",
+        referencedTableName: "parents",
+        referencedColumnName: "id",
+        ordinalPosition: 2
+      }
+    ],
+    primaryKeysByTable: {
+      items: ["id"],
+      parents: ["id"]
+    }
+  });
+
+  await assert.rejects(
+    () => introspectCrudTableSnapshot(knex, { tableName: "items" }),
+    /supports only single-column foreign keys.*2 columns/
+  );
+});
+
+test("introspectCrudTableSnapshot rejects foreign keys to non-primary business keys", async () => {
+  const { knex } = createKnexRawDouble({
+    columns: validIdColumns([
+      {
+        columnName: "workspace_slug",
+        dataType: "varchar",
+        columnType: "varchar(190)",
+        isNullable: "NO",
+        extra: "",
+        ordinalPosition: 2
+      }
+    ]),
+    primaryKeyColumns: [{ columnName: "id" }],
+    foreignKeys: [
+      {
+        constraintName: "items_workspace_slug_foreign",
+        columnName: "workspace_slug",
+        referencedTableName: "workspaces",
+        referencedColumnName: "slug",
+        ordinalPosition: 1
+      }
+    ],
+    primaryKeysByTable: {
+      items: ["id"],
+      workspaces: ["id"]
+    }
+  });
+
+  await assert.rejects(
+    () => introspectCrudTableSnapshot(knex, { tableName: "items" }),
+    /must target the primary key "workspaces.id", not "workspaces.slug"/
+  );
+});
+
+test("introspectCrudTableSnapshot rejects foreign keys to composite primary keys", async () => {
+  const { knex } = createKnexRawDouble({
+    columns: validIdColumns([
+      {
+        columnName: "parent_id",
+        dataType: "bigint",
+        columnType: "bigint unsigned",
+        isNullable: "NO",
+        extra: "",
+        ordinalPosition: 2
+      }
+    ]),
+    primaryKeyColumns: [{ columnName: "id" }],
+    foreignKeys: [
+      {
+        constraintName: "items_parent_foreign",
+        columnName: "parent_id",
+        referencedTableName: "parents",
+        referencedColumnName: "id",
+        ordinalPosition: 1
+      }
+    ],
+    primaryKeysByTable: {
+      items: ["id"],
+      parents: ["workspace_id", "id"]
+    }
+  });
+
+  await assert.rejects(
+    () => introspectCrudTableSnapshot(knex, { tableName: "items" }),
+    /primary key is not single-column.*workspace_id, id/
+  );
+});