@jskit-ai/crud-server-generator 0.1.27 → 0.1.29

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-server-generator",
-  version: "0.1.27",
+  version: "0.1.29",
   kind: "generator",
   description: "CRUD server generator with routes, actions, and persistence scaffolding.",
   options: {
@@ -15,9 +15,8 @@ export default Object.freeze({
     surface: {
       required: true,
       inputType: "text",
-      defaultFromConfig: "surfaceDefaultId",
       promptLabel: "Target surface",
-      promptHint: "Defaults to config.public.surfaceDefaultId. Must match an enabled surface id."
+      promptHint: "Must match an enabled surface id."
     },
     "ownership-filter": {
       required: true,
@@ -74,13 +73,19 @@ export default Object.freeze({
     server: {
       providers: [
         {
-          entrypoint: "src/server/CrudServiceProvider.js",
-          export: "CrudServiceProvider"
+          entrypoint: "src/server/CrudProvider.js",
+          export: "CrudProvider"
         }
       ]
     }
   },
   metadata: {
+    generatorSubcommands: {
+      "add-field": {
+        entrypoint: "src/server/subcommands/addField.js",
+        export: "runGeneratorSubcommand"
+      }
+    },
     apiSummary: {
       surfaces: [
         {
@@ -100,13 +105,13 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.18",
-        "@jskit-ai/crud-core": "0.1.27",
-        "@jskit-ai/database-runtime": "0.1.19",
-        "@jskit-ai/http-runtime": "0.1.18",
-        "@jskit-ai/kernel": "0.1.19",
-        "@jskit-ai/realtime": "0.1.18",
-        "@jskit-ai/users-core": "0.1.28",
+        "@jskit-ai/auth-core": "0.1.20",
+        "@jskit-ai/crud-core": "0.1.29",
+        "@jskit-ai/database-runtime": "0.1.21",
+        "@jskit-ai/http-runtime": "0.1.20",
+        "@jskit-ai/kernel": "0.1.21",
+        "@jskit-ai/realtime": "0.1.20",
+        "@jskit-ai/users-core": "0.1.30",
         "@local/${option:namespace|kebab}": "file:packages/${option:namespace|kebab}",
         "typebox": "^1.0.81"
       },
@@ -145,8 +150,8 @@ export default Object.freeze({
         id: "crud-local-package-descriptor-${option:namespace|snake}"
       },
       {
-        from: "templates/src/local-package/server/CrudServiceProvider.js",
-        to: "packages/${option:namespace|kebab}/src/server/${option:namespace|pascal}ServiceProvider.js",
+        from: "templates/src/local-package/server/CrudProvider.js",
+        to: "packages/${option:namespace|kebab}/src/server/${option:namespace|pascal}Provider.js",
         reason: "Install app-local CRUD server provider.",
         category: "crud",
         id: "crud-local-package-server-provider-${option:namespace|snake}",

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "@jskit-ai/crud-server-generator",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
-    "./server/CrudServiceProvider": "./src/server/CrudServiceProvider.js",
+    "./server/CrudProvider": "./src/server/CrudProvider.js",
     "./server/crudModuleConfig": "./src/server/crudModuleConfig.js",
     "./shared": "./src/shared/index.js",
     "./shared/crud/crudResource": "./src/shared/crud/crudResource.js"
   },
   "dependencies": {
-    "@jskit-ai/crud-core": "0.1.27",
-    "@jskit-ai/database-runtime": "0.1.19",
-    "@jskit-ai/http-runtime": "0.1.18",
-    "@jskit-ai/kernel": "0.1.19",
-    "@jskit-ai/users-core": "0.1.28",
+    "@babel/parser": "^7.29.2",
+    "@jskit-ai/crud-core": "0.1.29",
+    "@jskit-ai/database-runtime": "0.1.21",
+    "@jskit-ai/http-runtime": "0.1.20",
+    "@jskit-ai/kernel": "0.1.21",
+    "@jskit-ai/users-core": "0.1.30",
+    "recast": "^0.23.11",
     "typebox": "^1.0.81"
   }
 }

package/src/server/{CrudServiceProvider.js → CrudProvider.js}

@@ -1,4 +1,4 @@
-class CrudServiceProvider {
+class CrudProvider {
   static id = "crud";
 
   static dependsOn = [];
@@ -8,4 +8,4 @@ class CrudServiceProvider {
   boot() {}
 }
 
-export { CrudServiceProvider };
+export { CrudProvider };

package/src/server/buildTemplateContext.js

@@ -8,7 +8,9 @@ import {
   resolveDatabaseConnectionFromEnvironment,
   toKnexClientId
 } from "@jskit-ai/database-runtime/shared";
-import { toSnakeCase } from "@jskit-ai/kernel/shared/support/stringCase";
+import { checkCrudLookupFormControl } from "@jskit-ai/crud-core/shared/crudFieldMetaSupport";
+import { normalizeCrudLookupNamespace } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { toCamelCase, toSnakeCase } from "@jskit-ai/kernel/shared/support/stringCase";
 
 const DEFAULT_ID_COLUMN = "id";
 const OWNERSHIP_FILTER_AUTO = "auto";
@@ -380,7 +382,14 @@ function renderResourceFieldSchema(column, { forOutput = false } = {}) {
 
 function renderInputNormalizer(column) {
   const typeKind = String(column.typeKind || "");
-  if (typeKind === "string" || typeKind === "time") {
+  const nullable = column?.nullable === true;
+  if (typeKind === "string") {
+    return "normalizeText";
+  }
+  if (typeKind === "time") {
+    if (nullable) {
+      return "(value) => { const normalized = normalizeText(value); return normalized || null; }";
+    }
     return "normalizeText";
   }
   if (typeKind === "integer") {
@@ -393,9 +402,15 @@ function renderInputNormalizer(column) {
     return "normalizeBoolean";
   }
   if (typeKind === "datetime") {
+    if (nullable) {
+      return "(value) => { const normalized = normalizeText(value); return normalized ? toDatabaseDateTimeUtc(normalized) : null; }";
+    }
     return "toDatabaseDateTimeUtc";
   }
   if (typeKind === "date") {
+    if (nullable) {
+      return "(value) => { const normalized = normalizeText(value); return normalized ? toIsoString(normalized).slice(0, 10) : null; }";
+    }
     return "(value) => toIsoString(value).slice(0, 10)";
   }
   if (typeKind === "json") {
@@ -692,8 +707,233 @@ function renderMigrationIndexLines(snapshot) {
   return lines.join("\n");
 }
 
+function renderMigrationForeignKeyLine(foreignKey = {}) {
+  const columns = Array.isArray(foreignKey.columns)
+    ? foreignKey.columns
+        .map((column) => normalizeText(column?.name))
+        .filter(Boolean)
+    : [];
+  const referencedColumns = Array.isArray(foreignKey.columns)
+    ? foreignKey.columns
+        .map((column) => normalizeText(column?.referencedName))
+        .filter(Boolean)
+    : [];
+  const referencedTableName = normalizeText(foreignKey.referencedTableName);
+  const foreignKeyName = normalizeText(foreignKey.name);
+  if (columns.length < 1 || referencedColumns.length < 1 || !referencedTableName) {
+    return "";
+  }
+
+  let line = `    table.foreign(${JSON.stringify(columns)}`;
+  if (foreignKeyName) {
+    line += `, ${JSON.stringify(foreignKeyName)}`;
+  }
+  line += `).references(${JSON.stringify(referencedColumns)}).inTable(${JSON.stringify(referencedTableName)})`;
+
+  const updateRule = normalizeText(foreignKey.updateRule).toUpperCase();
+  if (updateRule) {
+    line += `.onUpdate(${JSON.stringify(updateRule)})`;
+  }
+  const deleteRule = normalizeText(foreignKey.deleteRule).toUpperCase();
+  if (deleteRule) {
+    line += `.onDelete(${JSON.stringify(deleteRule)})`;
+  }
+  line += ";";
+
+  return line;
+}
+
+function renderMigrationForeignKeyLines(snapshot) {
+  const foreignKeys = Array.isArray(snapshot.foreignKeys) ? snapshot.foreignKeys : [];
+  const lines = foreignKeys
+    .map((foreignKey) => renderMigrationForeignKeyLine(foreignKey))
+    .filter(Boolean);
+  return lines.join("\n");
+}
+
+function mergeFieldMetaEntries(baseEntries = [], patchEntries = []) {
+  const mergedByKey = new Map();
+  for (const sourceEntry of [...baseEntries, ...patchEntries]) {
+    const key = normalizeText(sourceEntry?.key);
+    if (!key) {
+      continue;
+    }
+    const existing = mergedByKey.get(key) || {};
+    const next = {
+      ...existing,
+      ...sourceEntry,
+      key
+    };
+    if (existing.relation || sourceEntry.relation) {
+      next.relation = {
+        ...(existing.relation && typeof existing.relation === "object" ? existing.relation : {}),
+        ...(sourceEntry.relation && typeof sourceEntry.relation === "object" ? sourceEntry.relation : {})
+      };
+    }
+    if (existing.ui || sourceEntry.ui) {
+      next.ui = {
+        ...(existing.ui && typeof existing.ui === "object" ? existing.ui : {}),
+        ...(sourceEntry.ui && typeof sourceEntry.ui === "object" ? sourceEntry.ui : {})
+      };
+    }
+    mergedByKey.set(key, next);
+  }
+
+  return [...mergedByKey.values()].sort((left, right) => left.key.localeCompare(right.key));
+}
+
+function resolveLookupNamespaceFromTableName(tableName = "") {
+  const normalizedTableName = toSnakeCase(normalizeText(tableName));
+  if (!normalizedTableName) {
+    return "";
+  }
+
+  return normalizedTableName.replace(/_/g, "-");
+}
+
+function buildFieldMetaEntries({ outputColumns = [], writableColumns = [], snapshot = {} } = {}) {
+  const fieldColumns = [...outputColumns, ...writableColumns];
+  const fieldColumnsByName = new Map();
+  const fieldColumnsByKey = new Map();
+  for (const column of fieldColumns) {
+    const columnName = normalizeText(column?.name);
+    const key = normalizeText(column?.key);
+    if (columnName && !fieldColumnsByName.has(columnName)) {
+      fieldColumnsByName.set(columnName, column);
+    }
+    if (key && !fieldColumnsByKey.has(key)) {
+      fieldColumnsByKey.set(key, column);
+    }
+  }
+
+  const dbColumnEntries = [];
+  for (const column of fieldColumnsByKey.values()) {
+    const key = normalizeText(column?.key);
+    const name = normalizeText(column?.name);
+    if (!key || !name) {
+      continue;
+    }
+    if (toSnakeCase(key) === name) {
+      continue;
+    }
+    dbColumnEntries.push({
+      key,
+      dbColumn: name
+    });
+  }
+
+  const relationEntries = [];
+  const foreignKeys = Array.isArray(snapshot.foreignKeys) ? snapshot.foreignKeys : [];
+  for (const foreignKey of foreignKeys) {
+    const columns = Array.isArray(foreignKey?.columns) ? foreignKey.columns : [];
+    if (columns.length !== 1) {
+      const name = normalizeText(foreignKey?.name) || "unnamed_foreign_key";
+      throw new Error(
+        `CRUD generation supports only single-column foreign keys. Constraint "${name}" has ${columns.length} columns.`
+      );
+    }
+
+    const localColumnName = normalizeText(columns[0]?.name);
+    const referencedColumnName = normalizeText(columns[0]?.referencedName);
+    const referencedTableName = normalizeText(foreignKey?.referencedTableName);
+    if (!localColumnName || !referencedColumnName || !referencedTableName) {
+      continue;
+    }
+
+    const localColumn = fieldColumnsByName.get(localColumnName);
+    if (!localColumn || localColumn.isOwnerColumn === true) {
+      continue;
+    }
+
+    relationEntries.push({
+      key: localColumn.key,
+      relation: {
+        kind: "lookup",
+        namespace: resolveLookupNamespaceFromTableName(referencedTableName),
+        valueKey: toCamelCase(referencedColumnName)
+      },
+      ui: {
+        formControl: "autocomplete"
+      }
+    });
+  }
+
+  return mergeFieldMetaEntries(dbColumnEntries, relationEntries);
+}
+
+function renderFieldMetaEntryLines(entry = {}) {
+  const lines = ["RESOURCE_FIELD_META.push({"];
+  const topLevelProperties = [`key: ${JSON.stringify(entry.key)}`];
+  const dbColumn = normalizeText(entry.dbColumn);
+  if (dbColumn) {
+    topLevelProperties.push(`dbColumn: ${JSON.stringify(dbColumn)}`);
+  }
+
+  const relation = entry.relation && typeof entry.relation === "object" ? entry.relation : null;
+  if (relation) {
+    const targetResourceNamespace = normalizeCrudLookupNamespace(relation.targetResource);
+    const relationNamespace =
+      normalizeCrudLookupNamespace(relation.namespace) ||
+      normalizeCrudLookupNamespace(relation.apiPath) ||
+      normalizeCrudLookupNamespace(relation?.source?.path) ||
+      targetResourceNamespace;
+    if (!relationNamespace) {
+      throw new Error(`crud template context fieldMeta["${normalizeText(entry.key)}"] lookup relation requires namespace.`);
+    }
+    const relationLines = [
+      "relation: {",
+      `  kind: ${JSON.stringify(normalizeText(relation.kind) || "lookup")},`,
+      `  namespace: ${JSON.stringify(relationNamespace)},`,
+      `  valueKey: ${JSON.stringify(normalizeText(relation.valueKey) || "id")},`
+    ];
+    const labelKey = normalizeText(relation.labelKey);
+    if (labelKey) {
+      relationLines.push(`  labelKey: ${JSON.stringify(labelKey)}`);
+    } else {
+      relationLines[relationLines.length - 1] = relationLines[relationLines.length - 1].replace(/,$/, "");
+    }
+    relationLines.push("}");
+    topLevelProperties.push(relationLines.join("\n"));
+  }
+
+  const formControl = checkCrudLookupFormControl(entry?.ui?.formControl, {
+    context: `resource.fieldMeta["${normalizeText(entry.key)}"].ui.formControl`,
+    defaultValue: relation ? "autocomplete" : ""
+  });
+  if (formControl) {
+    topLevelProperties.push(
+      [
+        "ui: {",
+        `  formControl: ${JSON.stringify(formControl)} // or "select"`,
+        "}"
+      ].join("\n")
+    );
+  }
+
+  for (const [index, propertyBlock] of topLevelProperties.entries()) {
+    const blockLines = String(propertyBlock || "").split("\n");
+    const isLastProperty = index >= topLevelProperties.length - 1;
+    const propertySuffix = isLastProperty ? "" : ",";
+    for (const [lineIndex, line] of blockLines.entries()) {
+      const isLastLine = lineIndex >= blockLines.length - 1;
+      lines.push(`  ${line}${isLastLine ? propertySuffix : ""}`);
+    }
+  }
+
+  lines.push("});");
+  return lines.join("\n");
+}
+
+function renderResourceFieldMetaPushLines(entries = []) {
+  const sourceEntries = Array.isArray(entries) ? entries : [];
+  if (sourceEntries.length < 1) {
+    return "";
+  }
+
+  return sourceEntries.map((entry) => renderFieldMetaEntryLines(entry)).join("\n\n");
+}
+
 function buildReplacementsFromSnapshot({
-  namespace,
   snapshot,
   resolvedOwnershipFilter
 }) {
@@ -704,34 +944,26 @@ function buildReplacementsFromSnapshot({
     .filter((column) => !column.nullable && column.hasDefault !== true)
     .map((column) => column.key);
   const resourceColumns = [...outputColumns, ...writableColumns];
-
-  const outputKeys = outputColumns.map((column) => column.key);
-  const writeKeys = writableColumns.map((column) => column.key);
-  const columnOverrides = {};
-  const seenOverrideKeys = new Set();
-  for (const column of [...outputColumns, ...writableColumns]) {
-    const key = column.key;
-    if (!key || seenOverrideKeys.has(key)) {
-      continue;
-    }
-    seenOverrideKeys.add(key);
-    const guessedColumn = toSnakeCase(key);
-    const actualColumn = column.name;
-    if (typeof actualColumn === "string" && actualColumn && actualColumn !== guessedColumn) {
-      columnOverrides[key] = actualColumn;
-    }
-  }
-  const createdAtColumn = scaffoldColumns.find((column) => column.isCreatedAtColumn)?.name || "";
-  const updatedAtColumn = scaffoldColumns.find((column) => column.isUpdatedAtColumn)?.name || "";
+  const fieldMetaEntries = buildFieldMetaEntries({
+    outputColumns,
+    writableColumns,
+    snapshot
+  });
   const needsFiniteInteger = resourceColumns.some((column) => column.typeKind === "integer");
   const needsFiniteNumber = resourceColumns.some((column) => column.typeKind === "number");
   const needsDateTimeOutput = outputColumns.some((column) => column.typeKind === "datetime");
   const needsDateTimeInput = writableColumns.some((column) => column.typeKind === "datetime");
+  const needsNullableDateTimeInput = writableColumns.some(
+    (column) => column.typeKind === "datetime" && column.nullable === true
+  );
+  const needsNullableDateInput = writableColumns.some(
+    (column) => column.typeKind === "date" && column.nullable === true
+  );
   const needsDate = resourceColumns.some((column) => column.typeKind === "date");
   const needsJson = resourceColumns.some((column) => column.typeKind === "json");
   const needsNormalizeText = resourceColumns.some((column) =>
     column.typeKind === "string" || column.typeKind === "time"
-  );
+  ) || needsNullableDateTimeInput || needsNullableDateInput;
   const needsNormalizeBoolean = resourceColumns.some((column) => column.typeKind === "boolean");
   const needsNormalizeIfInSource = writableColumns.length > 0;
   const outputColumnsWithNormalizer = outputColumns.filter(
@@ -769,13 +1001,10 @@ function buildReplacementsFromSnapshot({
     __JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__: renderResourceInputNormalizationLines(writableColumns),
     __JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__: renderResourceOutputNormalizationLines(outputColumns),
     __JSKIT_CRUD_RESOURCE_CREATE_REQUIRED_FIELDS__: JSON.stringify(createRequiredFieldKeys),
-    __JSKIT_CRUD_REPOSITORY_OUTPUT_KEYS__: JSON.stringify(outputKeys),
-    __JSKIT_CRUD_REPOSITORY_WRITE_KEYS__: JSON.stringify(writeKeys),
-    __JSKIT_CRUD_REPOSITORY_COLUMN_OVERRIDES__: JSON.stringify(columnOverrides),
-    __JSKIT_CRUD_REPOSITORY_CREATED_AT_COLUMN__: JSON.stringify(createdAtColumn),
-    __JSKIT_CRUD_REPOSITORY_UPDATED_AT_COLUMN__: JSON.stringify(updatedAtColumn),
+    __JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__: renderResourceFieldMetaPushLines(fieldMetaEntries),
     __JSKIT_CRUD_MIGRATION_COLUMN_LINES__: renderMigrationColumnLines(snapshot),
-    __JSKIT_CRUD_MIGRATION_INDEX_LINES__: renderMigrationIndexLines(snapshot)
+    __JSKIT_CRUD_MIGRATION_INDEX_LINES__: renderMigrationIndexLines(snapshot),
+    __JSKIT_CRUD_MIGRATION_FOREIGN_KEY_LINES__: renderMigrationForeignKeyLines(snapshot)
   });
 
   return replacements;
@@ -839,7 +1068,6 @@ async function buildCrudTemplateContext(input = {}) {
   );
 
   return buildReplacementsFromSnapshot({
-    namespace,
     snapshot,
     resolvedOwnershipFilter
   });
@@ -865,7 +1093,25 @@ const __testables = Object.freeze({
   resolveOwnershipFilterForGeneration,
   buildReplacementsFromSnapshot,
   parseDotEnvLine,
-  renderMigrationColumnLine
+  renderMigrationColumnLine,
+  renderMigrationForeignKeyLine,
+  resolveScaffoldColumns,
+  renderPropertyAccess,
+  renderResourceFieldSchema,
+  renderInputNormalizer,
+  renderOutputNormalizerExpression,
+  resolveGenerationSnapshot,
+  buildFieldMetaEntries
 });
 
-export { buildTemplateContext, __testables };
+export {
+  buildTemplateContext,
+  resolveScaffoldColumns,
+  renderPropertyAccess,
+  resolveGenerationSnapshot,
+  renderResourceFieldSchema,
+  renderInputNormalizer,
+  renderOutputNormalizerExpression,
+  buildFieldMetaEntries,
+  __testables
+};