@jskit-ai/crud-server-generator 0.1.56 → 0.1.57

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-server-generator",
-  version: "0.1.56",
+  version: "0.1.57",
   kind: "generator",
   description: "CRUD server generator with routes, actions, and persistence scaffolding.",
   options: {
@@ -151,13 +151,13 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.47",
-        "@jskit-ai/crud-core": "0.1.56",
-        "@jskit-ai/database-runtime": "0.1.48",
-        "@jskit-ai/http-runtime": "0.1.47",
-        "@jskit-ai/kernel": "0.1.48",
-        "@jskit-ai/realtime": "0.1.47",
-        "@jskit-ai/users-core": "0.1.58",
+        "@jskit-ai/auth-core": "0.1.48",
+        "@jskit-ai/crud-core": "0.1.57",
+        "@jskit-ai/database-runtime": "0.1.49",
+        "@jskit-ai/http-runtime": "0.1.48",
+        "@jskit-ai/kernel": "0.1.49",
+        "@jskit-ai/realtime": "0.1.48",
+        "@jskit-ai/users-core": "0.1.59",
         "@local/${option:namespace|kebab}": "file:packages/${option:namespace|kebab}",
         "typebox": "^1.0.81"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-server-generator",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -13,11 +13,11 @@
   },
   "dependencies": {
     "@babel/parser": "^7.29.2",
-    "@jskit-ai/crud-core": "0.1.56",
-    "@jskit-ai/database-runtime": "0.1.48",
-    "@jskit-ai/http-runtime": "0.1.47",
-    "@jskit-ai/kernel": "0.1.48",
-    "@jskit-ai/users-core": "0.1.58",
+    "@jskit-ai/crud-core": "0.1.57",
+    "@jskit-ai/database-runtime": "0.1.49",
+    "@jskit-ai/http-runtime": "0.1.48",
+    "@jskit-ai/kernel": "0.1.49",
+    "@jskit-ai/users-core": "0.1.59",
     "recast": "^0.23.11",
     "typebox": "^1.0.81"
   }

package/src/server/buildTemplateContext.js

@@ -391,9 +391,194 @@ function resolveColumnKey(column, idColumn) {
   return String(column.key || "");
 }
 
+const NUMERIC_CHECK_CONSTRAINT_PATTERN = /(?:`([^`]+)`|([A-Za-z_][A-Za-z0-9_]*))\s*(>=|>|<=|<)\s*(-?\d+(?:\.\d+)?)/g;
+
+function normalizeNumericBoundValue(value, scale = null) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return null;
+  }
+  if (!Number.isInteger(scale) || scale < 0) {
+    return parsed;
+  }
+  return Number(parsed.toFixed(scale));
+}
+
+function resolveNumericExclusiveStep(column) {
+  if (column?.typeKind === "integer") {
+    return 1;
+  }
+  if (column?.typeKind === "number" && Number.isInteger(column?.numericScale) && column.numericScale > 0) {
+    return 1 / (10 ** column.numericScale);
+  }
+  return null;
+}
+
+function applyLowerBound(current = null, candidate = null) {
+  if (!candidate) {
+    return current;
+  }
+  if (!current) {
+    return candidate;
+  }
+  if (candidate.value > current.value) {
+    return candidate;
+  }
+  if (candidate.value < current.value) {
+    return current;
+  }
+  if (candidate.exclusive === true && current.exclusive !== true) {
+    return candidate;
+  }
+  return current;
+}
+
+function applyUpperBound(current = null, candidate = null) {
+  if (!candidate) {
+    return current;
+  }
+  if (!current) {
+    return candidate;
+  }
+  if (candidate.value < current.value) {
+    return candidate;
+  }
+  if (candidate.value > current.value) {
+    return current;
+  }
+  if (candidate.exclusive === true && current.exclusive !== true) {
+    return candidate;
+  }
+  return current;
+}
+
+function resolveColumnNumericBounds(snapshot = {}) {
+  const byColumnName = new Map();
+  const columns = Array.isArray(snapshot.columns) ? snapshot.columns : [];
+  const checkConstraints = Array.isArray(snapshot.checkConstraints) ? snapshot.checkConstraints : [];
+  const numericColumnsByName = new Map(
+    columns
+      .filter((column) => column?.typeKind === "integer" || column?.typeKind === "number")
+      .map((column) => [String(column.name || ""), column])
+  );
+
+  function getColumnBounds(columnName) {
+    if (!byColumnName.has(columnName)) {
+      byColumnName.set(columnName, {
+        minimum: null,
+        exclusiveMinimum: null,
+        maximum: null,
+        exclusiveMaximum: null
+      });
+    }
+    return byColumnName.get(columnName);
+  }
+
+  for (const column of numericColumnsByName.values()) {
+    if (column.unsigned === true) {
+      const target = getColumnBounds(column.name);
+      target.minimum = 0;
+    }
+  }
+
+  for (const constraint of checkConstraints) {
+    const clause = String(constraint?.clause || "");
+    if (!clause) {
+      continue;
+    }
+
+    let match = null;
+    while ((match = NUMERIC_CHECK_CONSTRAINT_PATTERN.exec(clause)) != null) {
+      const columnName = String(match[1] || match[2] || "");
+      const operator = String(match[3] || "");
+      const rawValue = Number(match[4]);
+      const column = numericColumnsByName.get(columnName) || null;
+      if (!column || !Number.isFinite(rawValue)) {
+        continue;
+      }
+
+      const target = getColumnBounds(columnName);
+      if (operator === ">=" || operator === ">") {
+        let candidate = null;
+        if (operator === ">=") {
+          candidate = {
+            value: normalizeNumericBoundValue(rawValue, column.numericScale),
+            exclusive: false
+          };
+        } else {
+          const exclusiveStep = resolveNumericExclusiveStep(column);
+          if (exclusiveStep != null) {
+            candidate = {
+              value: normalizeNumericBoundValue(rawValue + exclusiveStep, column.numericScale),
+              exclusive: false
+            };
+          } else {
+            candidate = {
+              value: normalizeNumericBoundValue(rawValue, column.numericScale),
+              exclusive: true
+            };
+          }
+        }
+
+        const nextBound = applyLowerBound(
+          target.minimum != null || target.exclusiveMinimum != null
+            ? {
+                value: target.minimum ?? target.exclusiveMinimum,
+                exclusive: target.exclusiveMinimum != null
+              }
+            : null,
+          candidate
+        );
+        target.minimum = nextBound?.exclusive === true ? null : nextBound?.value ?? null;
+        target.exclusiveMinimum = nextBound?.exclusive === true ? nextBound?.value ?? null : null;
+        continue;
+      }
+
+      if (operator === "<=" || operator === "<") {
+        let candidate = null;
+        if (operator === "<=") {
+          candidate = {
+            value: normalizeNumericBoundValue(rawValue, column.numericScale),
+            exclusive: false
+          };
+        } else {
+          const exclusiveStep = resolveNumericExclusiveStep(column);
+          if (exclusiveStep != null) {
+            candidate = {
+              value: normalizeNumericBoundValue(rawValue - exclusiveStep, column.numericScale),
+              exclusive: false
+            };
+          } else {
+            candidate = {
+              value: normalizeNumericBoundValue(rawValue, column.numericScale),
+              exclusive: true
+            };
+          }
+        }
+
+        const nextBound = applyUpperBound(
+          target.maximum != null || target.exclusiveMaximum != null
+            ? {
+                value: target.maximum ?? target.exclusiveMaximum,
+                exclusive: target.exclusiveMaximum != null
+              }
+            : null,
+          candidate
+        );
+        target.maximum = nextBound?.exclusive === true ? null : nextBound?.value ?? null;
+        target.exclusiveMaximum = nextBound?.exclusive === true ? nextBound?.value ?? null : null;
+      }
+    }
+    NUMERIC_CHECK_CONSTRAINT_PATTERN.lastIndex = 0;
+  }
+
+  return byColumnName;
+}
+
 function resolveScaffoldColumns(snapshot) {
   const idColumn = String(snapshot.idColumn || DEFAULT_ID_COLUMN);
   const sourceColumns = Array.isArray(snapshot.columns) ? snapshot.columns : [];
+  const numericBoundsByColumnName = resolveColumnNumericBounds(snapshot);
   const foreignKeyColumnNames = new Set(
     (Array.isArray(snapshot.foreignKeys) ? snapshot.foreignKeys : [])
       .flatMap((foreignKey) => Array.isArray(foreignKey?.columns) ? foreignKey.columns : [])
@@ -427,6 +612,7 @@ function resolveScaffoldColumns(snapshot) {
 
     return Object.freeze({
       ...column,
+      ...(numericBoundsByColumnName.get(column.name) || {}),
       key,
       isOwnerColumn,
       isIdColumn,
@@ -462,9 +648,19 @@ function renderPropertyAccess(sourceName, key) {
 
 function renderIntegerSchema(column) {
   const options = [];
-  if (column.unsigned === true) {
+  if (Number.isFinite(column?.minimum)) {
+    options.push(`minimum: ${column.minimum}`);
+  } else if (Number.isFinite(column?.exclusiveMinimum)) {
+    options.push(`exclusiveMinimum: ${column.exclusiveMinimum}`);
+  } else if (column.unsigned === true) {
     options.push("minimum: 0");
   }
+  if (Number.isFinite(column?.maximum)) {
+    options.push(`maximum: ${column.maximum}`);
+  }
+  if (Number.isFinite(column?.exclusiveMaximum)) {
+    options.push(`exclusiveMaximum: ${column.exclusiveMaximum}`);
+  }
   if (options.length > 0) {
     return `Type.Integer({ ${options.join(", ")} })`;
   }
@@ -499,7 +695,22 @@ function renderResourceFieldSchema(column, { forOutput = false } = {}) {
     }
     schemaExpression = renderIntegerSchema(column);
   } else if (typeKind === "number") {
-    schemaExpression = "Type.Number()";
+    const options = [];
+    if (Number.isFinite(column?.minimum)) {
+      options.push(`minimum: ${column.minimum}`);
+    }
+    if (Number.isFinite(column?.exclusiveMinimum)) {
+      options.push(`exclusiveMinimum: ${column.exclusiveMinimum}`);
+    }
+    if (Number.isFinite(column?.maximum)) {
+      options.push(`maximum: ${column.maximum}`);
+    }
+    if (Number.isFinite(column?.exclusiveMaximum)) {
+      options.push(`exclusiveMaximum: ${column.exclusiveMaximum}`);
+    }
+    schemaExpression = options.length > 0
+      ? `Type.Number({ ${options.join(", ")} })`
+      : "Type.Number()";
   } else if (typeKind === "boolean") {
     schemaExpression = "Type.Boolean()";
   } else if (typeKind === "datetime") {
@@ -520,13 +731,15 @@ function renderResourceFieldSchema(column, { forOutput = false } = {}) {
   return schemaExpression;
 }
 
-function renderResourceValidatorsImport({ needsHtmlTimeSchemas = false, needsRecordIdSchemas = false } = {}) {
+function renderResourceValidatorsImport({ needsHtmlTimeSchemas = false, recordIdValidatorImports = [] } = {}) {
   const imports = [
     "normalizeObjectInput",
     "createCursorListValidator"
   ];
-  if (needsRecordIdSchemas) {
-    imports.push("recordIdSchema", "recordIdInputSchema", "nullableRecordIdSchema", "nullableRecordIdInputSchema");
+  for (const importName of Array.isArray(recordIdValidatorImports) ? recordIdValidatorImports : []) {
+    if (!imports.includes(importName)) {
+      imports.push(importName);
+    }
   }
   if (needsHtmlTimeSchemas) {
     imports.push("HTML_TIME_STRING_SCHEMA", "NULLABLE_HTML_TIME_STRING_SCHEMA");
@@ -534,6 +747,19 @@ function renderResourceValidatorsImport({ needsHtmlTimeSchemas = false, needsRec
   return `import {\n  ${imports.join(",\n  ")}\n} from "@jskit-ai/kernel/shared/validators";`;
 }
 
+function resolveRecordIdValidatorImports(...sources) {
+  const imports = ["recordIdSchema"];
+  const joinedSource = sources
+    .map((source) => String(source || ""))
+    .join("\n");
+  for (const importName of ["recordIdInputSchema", "nullableRecordIdSchema", "nullableRecordIdInputSchema"]) {
+    if (joinedSource.includes(importName)) {
+      imports.push(importName);
+    }
+  }
+  return imports;
+}
+
 function renderInputNormalizer(column) {
   const typeKind = String(column.typeKind || "");
   const nullable = column?.nullable === true;
@@ -1621,6 +1847,7 @@ function buildReplacementsFromSnapshot({
       requiresNamedPermissions
     }),
     __JSKIT_CRUD_ROUTE_SURFACE_REQUIRES_WORKSPACE__: String(surfaceRequiresWorkspace === true),
+    __JSKIT_CRUD_ROUTE_BASE__: JSON.stringify(surfaceRequiresWorkspace === true ? "/w/:workspaceSlug" : "/"),
     __JSKIT_CRUD_ROUTE_WORKSPACE_SUPPORT_IMPORTS__: renderRouteWorkspaceSupportImports({
       surfaceRequiresWorkspace
     }),
@@ -1656,7 +1883,14 @@ function buildReplacementsFromSnapshot({
     }),
     __JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__: renderResourceValidatorsImport({
       needsHtmlTimeSchemas,
-      needsRecordIdSchemas
+      recordIdValidatorImports: resolveRecordIdValidatorImports(
+        renderResourceSchemaPropertyLines(outputColumns, {
+          forOutput: true
+        }),
+        renderResourceSchemaPropertyLines(writableColumns, {
+          forOutput: false
+        })
+      )
     }),
     __JSKIT_CRUD_RESOURCE_DATABASE_RUNTIME_IMPORT__: renderResourceDatabaseRuntimeImport({
       needsToIsoString: needsDateTimeOutput || needsDate,

package/templates/src/local-package/server/registerRoutes.js

@@ -30,7 +30,7 @@ function registerRoutes(
   const router = app.make("jskit.http.router");
   const normalizedRouteSurface = normalizeSurfaceId(routeSurface);
   const routeBase = resolveScopedApiBasePath({
-    routeBase: __JSKIT_CRUD_ROUTE_SURFACE_REQUIRES_WORKSPACE__ ? "/w/:workspaceSlug" : "/",
+    routeBase: __JSKIT_CRUD_ROUTE_BASE__,
     relativePath: routeRelativePath,
     strictParams: false
   });

package/test/buildTemplateContext.test.js

@@ -738,6 +738,118 @@ test("buildReplacementsFromSnapshot preserves custom collations, hash unique ind
   );
 });
 
+test("resolveScaffoldColumns derives resource numeric bounds from check constraints", () => {
+  const snapshot = createSnapshot({
+    tableName: "batch_receivals",
+    hasWorkspaceIdColumn: false,
+    hasUserIdColumn: false
+  });
+
+  const inputWeightColumn = Object.freeze({
+    name: "input_weight",
+    key: "inputWeight",
+    dataType: "decimal",
+    columnType: "decimal(10,3)",
+    typeKind: "number",
+    nullable: false,
+    hasDefault: false,
+    defaultValue: null,
+    autoIncrement: false,
+    unsigned: false,
+    extra: "",
+    maxLength: null,
+    numericPrecision: 10,
+    numericScale: 3,
+    datetimePrecision: null,
+    characterSetName: "",
+    collationName: "",
+    enumValues: Object.freeze([])
+  });
+
+  const batchedDailySequenceColumn = Object.freeze({
+    name: "batched_daily_sequence",
+    key: "batchedDailySequence",
+    dataType: "int",
+    columnType: "int unsigned",
+    typeKind: "integer",
+    nullable: false,
+    hasDefault: false,
+    defaultValue: null,
+    autoIncrement: false,
+    unsigned: true,
+    extra: "",
+    maxLength: null,
+    numericPrecision: 10,
+    numericScale: 0,
+    datetimePrecision: null,
+    characterSetName: "",
+    collationName: "",
+    enumValues: Object.freeze([])
+  });
+
+  const moistureLevelColumn = Object.freeze({
+    name: "moisture_level",
+    key: "moistureLevel",
+    dataType: "decimal",
+    columnType: "decimal(5,2)",
+    typeKind: "number",
+    nullable: true,
+    hasDefault: false,
+    defaultValue: null,
+    autoIncrement: false,
+    unsigned: false,
+    extra: "",
+    maxLength: null,
+    numericPrecision: 5,
+    numericScale: 2,
+    datetimePrecision: null,
+    characterSetName: "",
+    collationName: "",
+    enumValues: Object.freeze([])
+  });
+
+  const scaffoldColumns = __testables.resolveScaffoldColumns({
+    ...snapshot,
+    columns: Object.freeze([
+      snapshot.columns[0],
+      inputWeightColumn,
+      batchedDailySequenceColumn,
+      moistureLevelColumn
+    ]),
+    checkConstraints: Object.freeze([
+      Object.freeze({
+        name: "chk_batch_receivals_input_weight",
+        clause: "`input_weight` > 0"
+      }),
+      Object.freeze({
+        name: "chk_batches_batched_daily_sequence",
+        clause: "`batched_daily_sequence` >= 1"
+      }),
+      Object.freeze({
+        name: "chk_batches_moisture_level",
+        clause: "`moisture_level` is null or `moisture_level` >= 0 and `moisture_level` <= 100"
+      })
+    ])
+  });
+
+  const inputWeight = scaffoldColumns.find((column) => column.name === "input_weight");
+  const batchedDailySequence = scaffoldColumns.find((column) => column.name === "batched_daily_sequence");
+  const moistureLevel = scaffoldColumns.find((column) => column.name === "moisture_level");
+
+  assert.equal(
+    __testables.renderResourceFieldSchema(inputWeight),
+    "Type.Number({ minimum: 0.001 })"
+  );
+  assert.equal(
+    __testables.renderResourceFieldSchema(batchedDailySequence),
+    "Type.Integer({ minimum: 1 })"
+  );
+  assert.equal(
+    __testables.renderResourceFieldSchema(moistureLevel),
+    "Type.Union([Type.Number({ minimum: 0, maximum: 100 }), Type.Null()])"
+  );
+});
+
 test("buildReplacementsFromSnapshot normalizes nullable temporal inputs without invalid date errors", () => {
   const snapshot = createSnapshot({
     hasWorkspaceIdColumn: false,
@@ -960,6 +1072,40 @@ test("buildReplacementsFromSnapshot uses shared framework time schemas in genera
   );
 });
 
+test("buildReplacementsFromSnapshot only imports record-id validator helpers that the resource actually uses", () => {
+  const snapshot = createSnapshot({
+    tableName: "pollen_types",
+    columns: [
+      {
+        name: "id",
+        dataType: "bigint",
+        columnType: "bigint unsigned",
+        nullable: false,
+        key: "id"
+      },
+      {
+        name: "name",
+        dataType: "varchar",
+        columnType: "varchar(32)",
+        nullable: false,
+        maxLength: 32,
+        key: "name"
+      }
+    ]
+  });
+
+  const replacements = __testables.buildReplacementsFromSnapshot({
+    namespace: "pollen-types",
+    snapshot,
+    resolvedOwnershipFilter: "public"
+  });
+
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__, /recordIdSchema/);
+  assert.doesNotMatch(replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__, /recordIdInputSchema/);
+  assert.doesNotMatch(replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__, /nullableRecordIdSchema/);
+  assert.doesNotMatch(replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__, /nullableRecordIdInputSchema/);
+});
+
 test("crud provider template uses shared lookup provider helpers instead of inline wiring", async () => {
   const testDirectory = path.dirname(fileURLToPath(import.meta.url));
   const templatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "CrudProvider.js");

package/test-support/templateServerFixture.js

@@ -89,6 +89,7 @@ function buildTemplateReplacements({
       ? "[workspaceSlugParamsValidator, recordIdParamsValidator]"
       : "recordIdParamsValidator"],
     ["__JSKIT_CRUD_ROUTE_SURFACE_REQUIRES_WORKSPACE__", String(surfaceRequiresWorkspace === true)],
+    ["__JSKIT_CRUD_ROUTE_BASE__", JSON.stringify(surfaceRequiresWorkspace ? "/w/:workspaceSlug" : "/")],
     ["__JSKIT_CRUD_ROUTE_WORKSPACE_SUPPORT_IMPORTS__", routeWorkspaceSupportImports],
     ["__JSKIT_CRUD_LIST_ROUTE_PARAMS_VALIDATOR_LINE__", surfaceRequiresWorkspace ? "      paramsValidator: routeParamsValidator," : ""],
     ["__JSKIT_CRUD_VIEW_ROUTE_PARAMS_VALIDATOR_LINE__", surfaceRequiresWorkspace ? "      paramsValidator: [routeParamsValidator, recordIdParamsValidator]," : "      paramsValidator: recordIdParamsValidator,"],