@jskit-ai/crud-server-generator 0.1.62 → 0.1.64

package/src/server/buildTemplateContext.js

@@ -9,7 +9,7 @@ import {
   toKnexClientId
 } from "@jskit-ai/database-runtime/shared";
 import { resolveCrudSurfacePolicyFromAppConfig } from "@jskit-ai/crud-core/server/crudModuleConfig";
-import { checkCrudLookupFormControl } from "@jskit-ai/crud-core/shared/crudFieldMetaSupport";
+import { checkCrudLookupFormControl } from "@jskit-ai/crud-core/shared/crudFieldSupport";
 import {
   importFreshModuleFromAbsolutePath,
   loadAppConfigFromModuleUrl,
@@ -663,322 +663,408 @@ function renderObjectPropertyKey(value) {
   return isIdentifier(key) ? key : JSON.stringify(key);
 }
 
-function renderPropertyAccess(sourceName, key) {
-  const normalizedKey = String(key || "");
-  if (isIdentifier(normalizedKey)) {
-    return `${sourceName}.${normalizedKey}`;
-  }
-  return `${sourceName}[${JSON.stringify(normalizedKey)}]`;
-}
-
-function renderIntegerSchema(column) {
-  const options = [];
+function renderBoundedNumberEntries(column) {
+  const entries = [];
   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");
+    entries.push(`min: ${column.minimum}`);
+  } else if (column?.unsigned === true) {
+    entries.push("min: 0");
   }
   if (Number.isFinite(column?.maximum)) {
-    options.push(`maximum: ${column.maximum}`);
-  }
-  if (Number.isFinite(column?.exclusiveMaximum)) {
-    options.push(`exclusiveMaximum: ${column.exclusiveMaximum}`);
+    entries.push(`max: ${column.maximum}`);
   }
-  if (options.length > 0) {
-    return `Type.Integer({ ${options.join(", ")} })`;
-  }
-  return "Type.Integer()";
+  return entries;
 }
 
-function renderStringSchema(column, { forOutput = false } = {}) {
-  const options = [];
-  if (!forOutput && Number.isInteger(column.maxLength) && column.maxLength > 0) {
-    options.push(`maxLength: ${column.maxLength}`);
-  }
-  const enumValues = Array.isArray(column.enumValues) ? column.enumValues.filter((entry) => entry != null) : [];
-  if (!forOutput && enumValues.length > 0) {
-    options.push(`enum: ${JSON.stringify(enumValues)}`);
+function resolveCanonicalResourceFieldRequired(column = {}) {
+  return column?.nullable !== true && column?.hasDefault !== true;
+}
+
+function renderCanonicalResourceOperations(column = {}) {
+  if (column?.isOwnerColumn === true) {
+    return "{}";
   }
-  if (options.length > 0) {
-    return `Type.String({ ${options.join(", ")} })`;
+
+  const entries = [
+    'output: { required: true }'
+  ];
+
+  if (column?.writable === true) {
+    entries.push(`create: { required: ${resolveCanonicalResourceFieldRequired(column)} }`);
+    entries.push("patch: { required: false }");
   }
-  return "Type.String()";
+
+  return [
+    "{",
+    ...entries.map((entry, index) => `  ${entry}${index < entries.length - 1 ? "," : ""}`),
+    "}"
+  ].join("\n");
 }
 
-function renderResourceFieldSchema(column, { forOutput = false } = {}) {
-  let schemaExpression = "Type.Any()";
-  const typeKind = String(column.typeKind || "");
+function renderCanonicalResourceFieldSchema(column, { fieldContractEntry = null } = {}) {
+  const entries = [];
+  const typeKind = String(column?.typeKind || "");
+  const isRequired = resolveCanonicalResourceFieldRequired(column);
+
   if (typeKind === "string") {
-    schemaExpression = renderStringSchema(column, { forOutput });
+    entries.push('type: "string"');
+    if (Number.isInteger(column?.maxLength) && column.maxLength > 0) {
+      entries.push(`maxLength: ${column.maxLength}`);
+    }
+    const enumValues = Array.isArray(column?.enumValues) ? column.enumValues.filter((entry) => entry != null) : [];
+    if (enumValues.length > 0) {
+      entries.push(`enum: ${JSON.stringify(enumValues)}`);
+    }
   } else if (typeKind === "integer") {
     if (column?.isRecordIdColumn === true) {
-      return forOutput
-        ? (column.nullable === true ? "nullableRecordIdSchema" : "recordIdSchema")
-        : (column.nullable === true ? "nullableRecordIdInputSchema" : "recordIdInputSchema");
+      entries.push('type: "id"');
+    } else {
+      entries.push('type: "integer"');
+      entries.push(...renderBoundedNumberEntries(column));
     }
-    schemaExpression = renderIntegerSchema(column);
   } else if (typeKind === "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()";
+    entries.push('type: "number"');
+    entries.push(...renderBoundedNumberEntries(column));
   } else if (typeKind === "boolean") {
-    schemaExpression = "Type.Boolean()";
+    entries.push('type: "boolean"');
   } else if (typeKind === "datetime") {
-    schemaExpression = 'Type.String({ format: "date-time", minLength: 1 })';
+    entries.push('type: "dateTime"');
+    const normalizedDefault = normalizeText(column?.defaultValue).toLowerCase();
+    if (normalizedDefault === "current_timestamp" || normalizedDefault === "current_timestamp()") {
+      entries.push('default: "now()"');
+    }
   } else if (typeKind === "date") {
-    schemaExpression = 'Type.String({ format: "date", minLength: 1 })';
+    entries.push('type: "date"');
   } else if (typeKind === "time") {
-    return column.nullable === true
-      ? "NULLABLE_HTML_TIME_STRING_SCHEMA"
-      : "HTML_TIME_STRING_SCHEMA";
-  } else if (typeKind === "json") {
-    schemaExpression = "Type.Any()";
+    entries.push('type: "time"');
+  } else {
+    entries.push('type: "none"');
   }
 
-  if (column.nullable === true) {
-    return `Type.Union([${schemaExpression}, Type.Null()])`;
+  if (isRequired) {
+    entries.push("required: true");
+  }
+  if (column?.nullable === true) {
+    entries.push("nullable: true");
+  }
+  if (shouldRenderJsonRestSearch(column)) {
+    entries.push("search: true");
+  }
+  if (column?.isOwnerColumn === true) {
+    entries.push("hidden: true");
   }
-  return schemaExpression;
-}
 
-function renderResourceValidatorsImport({ htmlTimeSchemaImports = [], recordIdValidatorImports = [] } = {}) {
-  const imports = [
-    "normalizeObjectInput",
-    "createCursorListValidator"
-  ];
-  for (const importName of Array.isArray(recordIdValidatorImports) ? recordIdValidatorImports : []) {
-    if (!imports.includes(importName)) {
-      imports.push(importName);
-    }
+  const actualField = normalizeText(fieldContractEntry?.actualField);
+  if (actualField) {
+    entries.push(`actualField: ${JSON.stringify(actualField)}`);
+  }
+
+  const parentRouteParamKey = normalizeText(fieldContractEntry?.parentRouteParamKey);
+  if (parentRouteParamKey) {
+    entries.push(`parentRouteParamKey: ${JSON.stringify(parentRouteParamKey)}`);
   }
-  for (const importName of Array.isArray(htmlTimeSchemaImports) ? htmlTimeSchemaImports : []) {
-    if (!imports.includes(importName)) {
-      imports.push(importName);
+
+  const relation = fieldContractEntry?.relation && typeof fieldContractEntry.relation === "object"
+    ? fieldContractEntry.relation
+    : null;
+  if (relation) {
+    const relationNamespace =
+      normalizeCrudLookupNamespace(relation.namespace) ||
+      normalizeCrudLookupNamespace(relation.apiPath) ||
+      normalizeCrudLookupNamespace(relation?.source?.path) ||
+      normalizeCrudLookupNamespace(relation.targetResource);
+    if (!relationNamespace) {
+      throw new Error(`crud template context field "${normalizeText(column?.key)}" lookup relation requires namespace.`);
     }
+
+    const relationEntries = [
+      `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) {
+      relationEntries.push(`labelKey: ${JSON.stringify(labelKey)}`);
+    }
+    entries.push(`relation: { ${relationEntries.join(", ")} }`);
   }
-  return `import {\n  ${imports.join(",\n  ")}\n} from "@jskit-ai/kernel/shared/validators";`;
-}
 
-function resolveHtmlTimeSchemaImports(columns = []) {
-  const imports = [];
-  for (const column of Array.isArray(columns) ? columns : []) {
-    if (column?.typeKind !== "time") {
-      continue;
+  const relationshipScopeName = resolveJsonRestRelationshipScopeName(fieldContractEntry);
+  const relationshipAlias = resolveJsonRestRelationshipAlias(column);
+  if (
+    relationshipScopeName &&
+    relationshipAlias &&
+    column?.isOwnerColumn !== true &&
+    column?.isForeignIdColumn === true
+  ) {
+    entries.push(`belongsTo: ${JSON.stringify(relationshipScopeName)}`);
+    entries.push(`as: ${JSON.stringify(relationshipAlias)}`);
+  }
+
+  const fieldUiOptions = normalizeFieldMetaUiOptions(fieldContractEntry?.ui?.options);
+  const formControl = checkCrudLookupFormControl(fieldContractEntry?.ui?.formControl, {
+    context: `resource schema field "${normalizeText(column?.key)}" ui.formControl`,
+    defaultValue: relation ? "autocomplete" : (fieldUiOptions.length > 0 ? "select" : "")
+  });
+  if (formControl || fieldUiOptions.length > 0) {
+    const uiEntries = [];
+    if (formControl) {
+      uiEntries.push(`formControl: ${JSON.stringify(formControl)}`);
     }
-    const importName = column.nullable === true
-      ? "NULLABLE_HTML_TIME_STRING_SCHEMA"
-      : "HTML_TIME_STRING_SCHEMA";
-    if (!imports.includes(importName)) {
-      imports.push(importName);
+    if (fieldUiOptions.length > 0) {
+      uiEntries.push(`options: ${JSON.stringify(fieldUiOptions)}`);
     }
+    entries.push(`ui: { ${uiEntries.join(", ")} }`);
+  }
+
+  const storageEntries = [];
+  if (fieldContractEntry?.storage?.mode === "virtual") {
+    storageEntries.push("virtual: true");
+  }
+  if (toSnakeCase(normalizeText(column?.key)) !== normalizeText(column?.name)) {
+    storageEntries.push(`column: ${JSON.stringify(column.name)}`);
   }
-  return imports;
+  if (normalizeText(column?.typeKind).toLowerCase() === "datetime") {
+    storageEntries.push('writeSerializer: "datetime-utc"');
+  }
+  if (storageEntries.length > 0) {
+    entries.push(`storage: { ${storageEntries.join(", ")} }`);
+  }
+
+  const operationsLines = renderCanonicalResourceOperations(column).split("\n");
+  const lines = [
+    "{",
+    ...entries.map((entry) => `  ${entry},`),
+    `  operations: ${operationsLines[0]}`
+  ];
+
+  for (const line of operationsLines.slice(1)) {
+    lines.push(`  ${line}`);
+  }
+
+  lines.push("}");
+  return lines.join("\n");
 }
 
-function resolveRecordIdValidatorImports(...sources) {
-  const imports = ["recordIdSchema"];
-  const joinedSource = sources
-    .map((source) => String(source || ""))
+function renderCanonicalResourceSchemaPropertyLines(columns = [], { fieldContractEntries = [] } = {}) {
+  const fieldContractByKey = Object.fromEntries(
+    (Array.isArray(fieldContractEntries) ? fieldContractEntries : [])
+      .map((entry) => [normalizeText(entry?.key), entry])
+      .filter(([key]) => key)
+  );
+
+  return (Array.isArray(columns) ? columns : [])
+    .filter((column) => column?.isIdColumn !== true)
+    .map((column) => {
+      const key = renderObjectPropertyKey(column.key);
+      const schemaLines = renderCanonicalResourceFieldSchema(column, {
+        fieldContractEntry: fieldContractByKey[normalizeText(column?.key)] || null
+      }).split("\n");
+      const lines = [`  ${key}: ${schemaLines[0]}`];
+      for (const line of schemaLines.slice(1)) {
+        lines.push(`  ${line}`);
+      }
+      lines[lines.length - 1] = `${lines[lines.length - 1]},`;
+      return lines.join("\n");
+    })
     .join("\n");
-  for (const importName of ["recordIdInputSchema", "nullableRecordIdSchema", "nullableRecordIdInputSchema"]) {
-    if (joinedSource.includes(importName)) {
-      imports.push(importName);
-    }
+}
+
+function resolveJsonRestRelationshipScopeName(fieldContractEntry = null) {
+  const namespace = normalizeText(fieldContractEntry?.relation?.namespace);
+  if (!namespace) {
+    return "";
   }
-  return imports;
+
+  return toCamelCase(namespace.replace(/\//g, "-"));
 }
 
-function renderInputNormalizer(column) {
-  const typeKind = String(column.typeKind || "");
-  const nullable = column?.nullable === true;
-  if (typeKind === "string") {
-    return "normalizeText";
+function resolveJsonRestRelationshipAlias(column = null) {
+  const key = normalizeText(column?.key);
+  if (!key) {
+    return "";
   }
-  if (typeKind === "time") {
-    if (nullable) {
-      return "(value) => { const normalized = normalizeText(value); return normalized || null; }";
-    }
-    return "normalizeText";
+  if (key.endsWith("Id") && key.length > 2) {
+    return `${key.slice(0, -2).slice(0, 1).toLowerCase()}${key.slice(0, -2).slice(1)}`;
+  }
+  return "";
+}
+
+function resolveJsonRestFieldType(column = {}) {
+  if (column?.isRecordIdColumn === true) {
+    return "id";
+  }
+
+  const typeKind = normalizeText(column?.typeKind).toLowerCase();
+  if (typeKind === "string") {
+    return "string";
   }
   if (typeKind === "integer") {
-    if (column?.isRecordIdColumn === true) {
-      if (nullable) {
-        return "(value) => normalizeRecordId(value, { fallback: null })";
-      }
-      return "normalizeRecordId";
-    }
-    return "normalizeFiniteInteger";
+    return "integer";
   }
   if (typeKind === "number") {
-    return "normalizeFiniteNumber";
+    return "number";
   }
   if (typeKind === "boolean") {
-    return "normalizeBoolean";
+    return "boolean";
   }
   if (typeKind === "datetime") {
-    if (nullable) {
-      return "(value) => { const normalized = normalizeText(value); return normalized ? toDatabaseDateTimeUtc(normalized) : null; }";
-    }
-    return "toDatabaseDateTimeUtc";
+    return "dateTime";
   }
   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)";
+    return "date";
   }
-  if (typeKind === "json") {
-    return "(value) => parseJsonValue(value, null, { fallback: null, allowNull: true })";
+  if (typeKind === "time") {
+    return "time";
   }
-  return "(value) => value";
+  return "string";
+}
+
+function shouldRenderJsonRestSearch(column = {}) {
+  return column?.isCreatedAtColumn !== true && column?.isUpdatedAtColumn !== true;
 }
 
-function renderOutputNormalizerExpression(column) {
-  const typeKind = String(column.typeKind || "");
-  const nullable = column?.nullable === true;
-  if (typeKind === "string" || typeKind === "time") {
-    return "normalizeText";
+function shouldRenderJsonRestStorage(column = {}) {
+  const key = normalizeText(column?.key);
+  const columnName = normalizeText(column?.name);
+  if (!key || !columnName) {
+    return false;
   }
-  if (typeKind === "integer") {
-    if (column?.isRecordIdColumn === true) {
-      if (nullable) {
-        return "(value) => normalizeRecordId(value, { fallback: null })";
-      }
-      return "normalizeRecordId";
+
+  if (toSnakeCase(key) !== columnName) {
+    return true;
+  }
+
+  return normalizeText(column?.typeKind).toLowerCase() === "datetime";
+}
+
+function renderJsonRestFieldSchema(column, { fieldContractEntry = null } = {}) {
+  const entries = [];
+  const type = resolveJsonRestFieldType(column);
+  entries.push(`type: ${JSON.stringify(type)}`);
+
+  if (column?.isIdColumn === true) {
+    entries.push("primary: true");
+    entries.push("required: true");
+    entries.push("search: true");
+  } else {
+    const required = column?.nullable !== true && column?.hasDefault !== true;
+    entries.push(`required: ${required}`);
+    if (shouldRenderJsonRestSearch(column)) {
+      entries.push("search: true");
     }
-    return "normalizeFiniteInteger";
   }
-  if (typeKind === "number") {
-    return "normalizeFiniteNumber";
+
+  if (column?.nullable === true) {
+    entries.push("nullable: true");
   }
-  if (typeKind === "boolean") {
-    return "normalizeBoolean";
+
+  if (type === "string" && Number.isInteger(column?.maxLength) && column.maxLength > 0) {
+    entries.push(`max: ${column.maxLength}`);
   }
-  if (typeKind === "datetime") {
-    return "toIsoString";
+
+  if (column?.isOwnerColumn === true) {
+    entries.push("hidden: true");
   }
-  if (typeKind === "date") {
-    return "(value) => toIsoString(value).slice(0, 10)";
+
+  const relationshipScopeName = resolveJsonRestRelationshipScopeName(fieldContractEntry);
+  const relationshipAlias = resolveJsonRestRelationshipAlias(column);
+  if (
+    relationshipScopeName &&
+    relationshipAlias &&
+    column?.isOwnerColumn !== true &&
+    column?.isForeignIdColumn === true
+  ) {
+    entries.push(`belongsTo: ${JSON.stringify(relationshipScopeName)}`);
+    entries.push(`as: ${JSON.stringify(relationshipAlias)}`);
   }
-  if (typeKind === "json") {
-    return "(value) => parseJsonValue(value, null, { fallback: null, allowNull: true })";
+
+  if (shouldRenderJsonRestStorage(column)) {
+    const storageEntries = [];
+    if (toSnakeCase(normalizeText(column?.key)) !== normalizeText(column?.name)) {
+      storageEntries.push(`column: ${JSON.stringify(column.name)}`);
+    }
+    if (normalizeText(column?.typeKind).toLowerCase() === "datetime") {
+      storageEntries.push("serialize: serializeNullableDateTime");
+    }
+    entries.push(`storage: { ${storageEntries.join(", ")} }`);
   }
-  return "";
-}
 
-function renderResourceSchemaPropertyLines(columns, { forOutput = false } = {}) {
-  const sourceColumns = Array.isArray(columns) ? columns : [];
-  return sourceColumns
-    .map((column) => {
-      const key = renderObjectPropertyKey(column.key);
-      const schemaExpression = renderResourceFieldSchema(column, { forOutput });
-      return `    ${key}: ${schemaExpression},`;
-    })
-    .join("\n");
+  return [
+    "{",
+    ...entries.map((entry, index) => `  ${entry}${index < entries.length - 1 ? "," : ""}`),
+    "}"
+  ].join("\n");
 }
 
-function renderResourceInputNormalizationLines(columns) {
-  const sourceColumns = Array.isArray(columns) ? columns : [];
-  return sourceColumns
-    .map((column) => {
-      const keyLiteral = JSON.stringify(String(column.key || ""));
-      const normalizer = renderInputNormalizer(column);
-      return `  normalizeIfInSource(source, normalized, ${keyLiteral}, ${normalizer});`;
-    })
-    .join("\n");
-}
+function renderJsonRestSchemaPropertyLines(columns = [], { fieldContractEntries = [] } = {}) {
+  const fieldContractByKey = Object.fromEntries(
+    (Array.isArray(fieldContractEntries) ? fieldContractEntries : [])
+      .map((entry) => [normalizeText(entry?.key), entry])
+      .filter(([key]) => key)
+  );
 
-function renderResourceOutputNormalizationLines(columns) {
-  const sourceColumns = Array.isArray(columns) ? columns : [];
-  return sourceColumns
+  return (Array.isArray(columns) ? columns : [])
+    .filter((column) => column?.isIdColumn !== true)
     .map((column) => {
       const key = renderObjectPropertyKey(column.key);
-      const sourceAccess = renderPropertyAccess("source", column.key);
-      const normalizer = renderOutputNormalizerExpression(column);
-      if (!normalizer) {
-        return `    ${key}: ${sourceAccess},`;
+      const schemaLines = renderJsonRestFieldSchema(column, {
+        fieldContractEntry: fieldContractByKey[normalizeText(column?.key)] || null
+      }).split("\n");
+      const lines = [`    ${key}: ${schemaLines[0]}`];
+      for (const line of schemaLines.slice(1)) {
+        lines.push(`    ${line}`);
       }
-      const nullishNormalizer = column.nullable === true ? "normalizeOrNull" : "normalizeIfPresent";
-      return `    ${key}: ${nullishNormalizer}(${sourceAccess}, ${normalizer}),`;
+      lines[lines.length - 1] = `${lines[lines.length - 1]},`;
+      return lines.join("\n");
     })
     .join("\n");
 }
 
-function renderResourceDatabaseRuntimeImport({ needsToIsoString = false, needsToDatabaseDateTimeUtc = false } = {}) {
-  const imports = [];
-  if (needsToIsoString) {
-    imports.push("toIsoString");
-  }
-  if (needsToDatabaseDateTimeUtc) {
-    imports.push("toDatabaseDateTimeUtc");
-  }
-  if (imports.length < 1) {
-    return "";
-  }
-  return `import {\n  ${imports.join(",\n  ")}\n} from "@jskit-ai/database-runtime/shared";`;
-}
+function renderJsonRestSearchSchemaLines(columns = []) {
+  const searchableStringKeys = (Array.isArray(columns) ? columns : [])
+    .filter((column) =>
+      normalizeText(column?.typeKind).toLowerCase() === "string" &&
+      column?.isOwnerColumn !== true &&
+      column?.isIdColumn !== true &&
+      column?.isCreatedAtColumn !== true &&
+      column?.isUpdatedAtColumn !== true
+    )
+    .map((column) => normalizeText(column?.key))
+    .filter(Boolean);
 
-function renderResourceJsonImport({ needsJson = false } = {}) {
-  if (!needsJson) {
-    return "";
+  const lines = [
+    '    id: { type: "id", actualField: "id" },'
+  ];
+
+  if (searchableStringKeys.length > 0) {
+    lines.push(
+      `    q: { type: "string", oneOf: ${JSON.stringify(searchableStringKeys)}, filterOperator: "like", splitBy: " ", matchAll: true },`
+    );
   }
-  return 'import { parseJsonValue } from "@jskit-ai/database-runtime/shared/repositoryOptions";';
+
+  return lines.join("\n");
 }
 
-function renderResourceNormalizeSupportImport({
-  needsNormalizeText = false,
-  needsNormalizeBoolean = false,
-  needsNormalizeFiniteNumber = false,
-  needsNormalizeFiniteInteger = false,
-  needsNormalizeRecordId = false,
-  needsNormalizeIfInSource = false,
-  needsNormalizeIfPresent = false,
-  needsNormalizeOrNull = false
-} = {}) {
-  const imports = [];
-  if (needsNormalizeText) {
-    imports.push("normalizeText");
-  }
-  if (needsNormalizeBoolean) {
-    imports.push("normalizeBoolean");
-  }
-  if (needsNormalizeFiniteNumber) {
-    imports.push("normalizeFiniteNumber");
-  }
-  if (needsNormalizeFiniteInteger) {
-    imports.push("normalizeFiniteInteger");
-  }
-  if (needsNormalizeRecordId) {
-    imports.push("normalizeRecordId");
-  }
-  if (needsNormalizeIfInSource) {
-    imports.push("normalizeIfInSource");
-  }
-  if (needsNormalizeIfPresent) {
-    imports.push("normalizeIfPresent");
-  }
-  if (needsNormalizeOrNull) {
-    imports.push("normalizeOrNull");
+function renderJsonRestDefaultSortLine(columns = []) {
+  const sourceColumns = Array.isArray(columns) ? columns : [];
+  const createdAtColumn = sourceColumns.find((column) => column?.isCreatedAtColumn === true);
+  if (createdAtColumn?.key) {
+    return `  defaultSort: ${JSON.stringify([`-${createdAtColumn.key}`])},`;
   }
-  if (imports.length < 1) {
-    return "";
+
+  const idColumn = sourceColumns.find((column) => column?.isIdColumn === true);
+  if (idColumn?.key) {
+    return `  defaultSort: ${JSON.stringify([`-${idColumn.key}`])},`;
   }
-  return `import {\n  ${imports.join(",\n  ")}\n} from "@jskit-ai/kernel/shared/support/normalize";`;
+
+  return "";
+}
+
+function renderResourceDefaultSortLiteral(columns = []) {
+  const sortLine = renderJsonRestDefaultSortLine(columns);
+  const match = sortLine.match(/defaultSort:\s*(.+),$/);
+  return match?.[1] || "[]";
 }
 
 function renderMigrationDefaultClause(column) {
@@ -1411,7 +1497,7 @@ function resolveEnumFieldMetaUiOptions(enumValues = []) {
   return normalizeFieldMetaUiOptions(options);
 }
 
-function buildFieldMetaEntries({ outputColumns = [], writableColumns = [], snapshot = {} } = {}) {
+function buildFieldContractEntries({ outputColumns = [], writableColumns = [], snapshot = {} } = {}) {
   const fieldColumns = [...outputColumns, ...writableColumns];
   const fieldColumnsByName = new Map();
   const fieldColumnsByKey = new Map();
@@ -1509,127 +1595,6 @@ function buildFieldMetaEntries({ outputColumns = [], writableColumns = [], snaps
   return mergeFieldMetaEntries(repositoryEntries, relationEntries, enumEntries);
 }
 
-function renderFieldMetaEntryLines(entry = {}) {
-  const lines = ["RESOURCE_FIELD_META.push({"];
-  const topLevelProperties = [`key: ${JSON.stringify(entry.key)}`];
-  const repositoryColumn = normalizeText(entry?.repository?.column);
-  if (repositoryColumn) {
-    topLevelProperties.push([
-      "repository: {",
-      `  column: ${JSON.stringify(repositoryColumn)}`,
-      "}"
-    ].join("\n"));
-  }
-
-  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 fieldUiOptions = normalizeFieldMetaUiOptions(entry?.ui?.options);
-  const formControl = checkCrudLookupFormControl(entry?.ui?.formControl, {
-    context: `resource.fieldMeta["${normalizeText(entry.key)}"].ui.formControl`,
-    defaultValue: relation ? "autocomplete" : (fieldUiOptions.length > 0 ? "select" : "")
-  });
-  if (formControl || fieldUiOptions.length > 0) {
-    const uiPropertyBlocks = [];
-    if (formControl) {
-      uiPropertyBlocks.push([
-        `formControl: ${JSON.stringify(formControl)}${relation ? " // or \"select\"" : ""}`
-      ]);
-    }
-    if (fieldUiOptions.length > 0) {
-      const optionsJsonLines = JSON.stringify(fieldUiOptions, null, 2).split("\n");
-      const optionPropertyLines = [`options: ${optionsJsonLines[0]}`];
-      for (const jsonLine of optionsJsonLines.slice(1)) {
-        optionPropertyLines.push(jsonLine);
-      }
-      uiPropertyBlocks.push(optionPropertyLines);
-    }
-
-    const uiLines = ["ui: {"];
-    for (const [propertyIndex, propertyLines] of uiPropertyBlocks.entries()) {
-      const isLastProperty = propertyIndex >= uiPropertyBlocks.length - 1;
-      const propertySuffix = isLastProperty ? "" : ",";
-      for (const [lineIndex, line] of propertyLines.entries()) {
-        const isLastLine = lineIndex >= propertyLines.length - 1;
-        uiLines.push(`  ${line}${isLastLine ? propertySuffix : ""}`);
-      }
-    }
-    uiLines.push("}");
-    topLevelProperties.push(
-      uiLines.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 renderRepositoryListConfigLines(snapshot = {}) {
-  const commentLines = [
-    "  // defaultLimit: 20,",
-    "  // maxLimit: 100,",
-    "  // searchColumns: [\"name\"],"
-  ];
-  const sourceColumns = Array.isArray(snapshot?.columns) ? snapshot.columns : [];
-  const hasCreatedAtColumn = sourceColumns.some((column = {}) => normalizeText(column?.name) === "created_at");
-  if (!hasCreatedAtColumn) {
-    return commentLines.join("\n");
-  }
-
-  return [
-    ...commentLines,
-    "  orderBy: [",
-    "    {",
-    "      column: \"created_at\",",
-    "      direction: \"desc\"",
-    "    }",
-    "  ]"
-  ].join("\n");
-}
-
 function buildCrudPermissionIds(namespace = "") {
   const permissionNamespace = toSnakeCase(namespace);
   if (!permissionNamespace) {
@@ -1728,14 +1693,10 @@ function renderRouteParamsValidatorLine(operation = "", { surfaceRequiresWorkspa
     if (!surfaceRequiresWorkspace) {
       return "";
     }
-    return "      paramsValidator: routeParamsValidator,";
+    return "      params: routeParamsValidator,";
   }
 
-  if (!surfaceRequiresWorkspace) {
-    return "      paramsValidator: recordIdParamsValidator,";
-  }
-
-  return "      paramsValidator: [routeParamsValidator, recordIdParamsValidator],";
+  return "      params: recordRouteParamsValidator,";
 }
 
 function renderRouteInputLines(operation = "", { surfaceRequiresWorkspace = true } = {}) {
@@ -1758,13 +1719,13 @@ function renderRouteInputLines(operation = "", { surfaceRequiresWorkspace = true
   }
 
   if (normalizedOperation === "create") {
-    lines.push("          payload: request.input.body");
+    lines.push("          ...(request.input.body || {})");
     return lines.join("\n");
   }
 
   if (normalizedOperation === "update") {
     lines.push("          recordId: request.input.params.recordId,");
-    lines.push("          patch: request.input.body");
+    lines.push("          ...(request.input.body || {})");
     return lines.join("\n");
   }
 
@@ -1772,32 +1733,89 @@ function renderRouteInputLines(operation = "", { surfaceRequiresWorkspace = true
   return lines.join("\n");
 }
 
-function renderActionInputValidatorExpression(operation = "", { surfaceRequiresWorkspace = true } = {}) {
-  const normalizedOperation = normalizeCrudOperation(operation, "CRUD action input validator operation");
-  const validators = [];
+function renderObjectSchemaDefinition(lines = [], { mode = "patch" } = {}) {
+  const entries = (Array.isArray(lines) ? lines : [])
+    .map((line) => String(line || "").trim())
+    .filter(Boolean)
+    .map((line) => line.endsWith(",") ? line.slice(0, -1) : line);
+
+  if (entries.length < 1) {
+    throw new TypeError("renderObjectSchemaDefinition requires at least one schema definition.");
+  }
 
-  if (surfaceRequiresWorkspace) {
-    validators.push("workspaceSlugParamsValidator");
+  if (entries.length === 1) {
+    return entries[0];
   }
 
-  if (normalizedOperation === "list") {
-    validators.push(
-      "listCursorPaginationQueryValidator",
-      "listSearchQueryValidator",
-      "listParentFilterQueryValidator",
-      "lookupIncludeQueryValidator"
-    );
-  } else if (normalizedOperation === "view") {
-    validators.push("recordIdParamsValidator", "lookupIncludeQueryValidator");
-  } else if (normalizedOperation === "create") {
-    validators.push("{ payload: resource.operations.create.bodyValidator }");
-  } else if (normalizedOperation === "update") {
-    validators.push("recordIdParamsValidator", "{ patch: resource.operations.patch.bodyValidator }");
-  } else {
-    validators.push("recordIdParamsValidator");
+  if (normalizeText(mode).toLowerCase() === "patch") {
+    return [
+      "composeSchemaDefinitions([",
+      ...entries.map((line) => `  ${line},`),
+      "])"
+    ].join("\n");
   }
 
-  return validators.length === 1 ? validators[0] : `[${validators.join(", ")}]`;
+  return [
+    "composeSchemaDefinitions([",
+    ...entries.map((line) => `  ${line},`),
+    "], {",
+    `  mode: ${JSON.stringify(mode)}`,
+    "})"
+  ].join("\n");
+}
+
+function renderActionInputExpressions({ surfaceRequiresWorkspace = true } = {}) {
+  const listLines = [];
+  const viewLines = [];
+  const createLines = [];
+  const updateLines = [];
+  const deleteLines = [];
+
+  if (surfaceRequiresWorkspace) {
+    listLines.push("workspaceSlugParamsValidator,");
+    viewLines.push("workspaceSlugParamsValidator,");
+    createLines.push("workspaceSlugParamsValidator,");
+    updateLines.push("workspaceSlugParamsValidator,");
+    deleteLines.push("workspaceSlugParamsValidator,");
+  }
+
+  listLines.push(
+    "listCursorPaginationQueryValidator,",
+    "listSearchQueryValidator,",
+    "listParentFilterQueryValidator,",
+    "lookupIncludeQueryValidator,"
+  );
+  viewLines.push(
+    "recordIdParamsValidator,",
+    "lookupIncludeQueryValidator,"
+  );
+  createLines.push("resource.operations.create.body,");
+  updateLines.push(
+    "recordIdParamsValidator,",
+    "resource.operations.patch.body,"
+  );
+  deleteLines.push("recordIdParamsValidator,");
+
+  return Object.freeze({
+    list: renderObjectSchemaDefinition(listLines),
+    view: renderObjectSchemaDefinition(viewLines),
+    create: renderObjectSchemaDefinition(createLines, { mode: "create" }),
+    update: renderObjectSchemaDefinition(updateLines),
+    delete: renderObjectSchemaDefinition(deleteLines)
+  });
+}
+
+function renderRouteValidatorConstants({ surfaceRequiresWorkspace = true } = {}) {
+  if (!surfaceRequiresWorkspace) {
+    return "";
+  }
+
+  return [
+    "const recordRouteParamsValidator = composeSchemaDefinitions([",
+    "  routeParamsValidator,",
+    "  recordIdParamsValidator",
+    "]);"
+  ].join("\n");
 }
 
 function buildReplacementsFromSnapshot({
@@ -1811,39 +1829,25 @@ function buildReplacementsFromSnapshot({
   const scaffoldColumns = resolveScaffoldColumns(snapshot);
   const outputColumns = scaffoldColumns.filter((column) => !column.isOwnerColumn);
   const writableColumns = scaffoldColumns.filter((column) => column.writable);
-  const createRequiredFieldKeys = writableColumns
-    .filter((column) => !column.nullable && column.hasDefault !== true)
-    .map((column) => column.key);
-  const resourceColumns = [...outputColumns, ...writableColumns];
-  const fieldMetaEntries = buildFieldMetaEntries({
+  const fieldContractEntries = buildFieldContractEntries({
     outputColumns,
     writableColumns,
     snapshot
   });
-  const needsFiniteInteger = resourceColumns.some((column) => column.typeKind === "integer" && column.isRecordIdColumn !== true);
-  const needsRecordIdSchemas = resourceColumns.some((column) => column.typeKind === "integer" && column.isRecordIdColumn === true);
-  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 htmlTimeSchemaImports = resolveHtmlTimeSchemaImports(resourceColumns);
-  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(
-    (column) => Boolean(renderOutputNormalizerExpression(column))
-  );
-  const needsNormalizeIfPresent = outputColumnsWithNormalizer.some((column) => column.nullable !== true);
-  const needsNormalizeOrNull = outputColumnsWithNormalizer.some((column) => column.nullable === true);
+  const actionInputExpressions = renderActionInputExpressions({
+    surfaceRequiresWorkspace
+  });
+  const resourceSchemaColumns = scaffoldColumns;
+  const resourceSchemaPropertyLines = renderCanonicalResourceSchemaPropertyLines(resourceSchemaColumns, {
+    fieldContractEntries
+  });
+  const resourceSearchSchemaLines = renderJsonRestSearchSchemaLines(resourceSchemaColumns);
+  const resourceDefaultSortLiteral = renderResourceDefaultSortLiteral(resourceSchemaColumns);
+  const jsonRestSchemaPropertyLines = renderJsonRestSchemaPropertyLines(resourceSchemaColumns, {
+    fieldContractEntries
+  });
+  const jsonRestSearchSchemaLines = renderJsonRestSearchSchemaLines(resourceSchemaColumns);
+  const jsonRestDefaultSortLine = renderJsonRestDefaultSortLine(resourceSchemaColumns);
 
   const replacements = Object.freeze({
     __JSKIT_CRUD_TABLE_NAME__: JSON.stringify(snapshot.tableName),
@@ -1856,36 +1860,26 @@ function buildReplacementsFromSnapshot({
     __JSKIT_CRUD_ACTION_WORKSPACE_VALIDATOR_IMPORT__: renderActionWorkspaceValidatorImport({
       surfaceRequiresWorkspace
     }),
+    __JSKIT_CRUD_LIST_ACTION_INPUT__: actionInputExpressions.list,
+    __JSKIT_CRUD_VIEW_ACTION_INPUT__: actionInputExpressions.view,
+    __JSKIT_CRUD_CREATE_ACTION_INPUT__: actionInputExpressions.create,
+    __JSKIT_CRUD_UPDATE_ACTION_INPUT__: actionInputExpressions.update,
+    __JSKIT_CRUD_DELETE_ACTION_INPUT__: actionInputExpressions.delete,
     __JSKIT_CRUD_LIST_ACTION_PERMISSION__: renderActionPermissionExpression("list", {
       requiresNamedPermissions
     }),
-    __JSKIT_CRUD_LIST_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("list", {
-      surfaceRequiresWorkspace
-    }),
     __JSKIT_CRUD_VIEW_ACTION_PERMISSION__: renderActionPermissionExpression("view", {
       requiresNamedPermissions
     }),
-    __JSKIT_CRUD_VIEW_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("view", {
-      surfaceRequiresWorkspace
-    }),
     __JSKIT_CRUD_CREATE_ACTION_PERMISSION__: renderActionPermissionExpression("create", {
       requiresNamedPermissions
     }),
-    __JSKIT_CRUD_CREATE_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("create", {
-      surfaceRequiresWorkspace
-    }),
     __JSKIT_CRUD_UPDATE_ACTION_PERMISSION__: renderActionPermissionExpression("update", {
       requiresNamedPermissions
     }),
-    __JSKIT_CRUD_UPDATE_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("update", {
-      surfaceRequiresWorkspace
-    }),
     __JSKIT_CRUD_DELETE_ACTION_PERMISSION__: renderActionPermissionExpression("delete", {
       requiresNamedPermissions
     }),
-    __JSKIT_CRUD_DELETE_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("delete", {
-      surfaceRequiresWorkspace
-    }),
     __JSKIT_CRUD_ROLE_CATALOG_PERMISSION_GRANTS__: renderRoleCatalogPermissionGrants(namespace, {
       requiresNamedPermissions
     }),
@@ -1894,6 +1888,10 @@ function buildReplacementsFromSnapshot({
     __JSKIT_CRUD_ROUTE_WORKSPACE_SUPPORT_IMPORTS__: renderRouteWorkspaceSupportImports({
       surfaceRequiresWorkspace
     }),
+    __JSKIT_CRUD_ROUTE_CONTRACTS_RESOURCE_ARGS__: surfaceRequiresWorkspace ? ",\n  routeParamsValidator" : "",
+    __JSKIT_CRUD_ROUTE_VALIDATOR_CONSTANTS__: renderRouteValidatorConstants({
+      surfaceRequiresWorkspace
+    }),
     __JSKIT_CRUD_LIST_ROUTE_PARAMS_VALIDATOR_LINE__: renderRouteParamsValidatorLine("list", {
       surfaceRequiresWorkspace
     }),
@@ -1924,45 +1922,15 @@ function buildReplacementsFromSnapshot({
     __JSKIT_CRUD_DELETE_ROUTE_INPUT_LINES__: renderRouteInputLines("delete", {
       surfaceRequiresWorkspace
     }),
-    __JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__: renderResourceValidatorsImport({
-      htmlTimeSchemaImports,
-      recordIdValidatorImports: resolveRecordIdValidatorImports(
-        renderResourceSchemaPropertyLines(outputColumns, {
-          forOutput: true
-        }),
-        renderResourceSchemaPropertyLines(writableColumns, {
-          forOutput: false
-        })
-      )
-    }),
-    __JSKIT_CRUD_RESOURCE_DATABASE_RUNTIME_IMPORT__: renderResourceDatabaseRuntimeImport({
-      needsToIsoString: needsDateTimeOutput || needsDate,
-      needsToDatabaseDateTimeUtc: needsDateTimeInput
-    }),
-    __JSKIT_CRUD_RESOURCE_NORMALIZE_SUPPORT_IMPORT__: renderResourceNormalizeSupportImport({
-      needsNormalizeText,
-      needsNormalizeBoolean,
-      needsNormalizeFiniteNumber: needsFiniteNumber,
-      needsNormalizeFiniteInteger: needsFiniteInteger,
-      needsNormalizeRecordId: needsRecordIdSchemas,
-      needsNormalizeIfInSource,
-      needsNormalizeIfPresent,
-      needsNormalizeOrNull
-    }),
-    __JSKIT_CRUD_RESOURCE_JSON_IMPORT__: renderResourceJsonImport({
-      needsJson
-    }),
-    __JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__: renderResourceSchemaPropertyLines(outputColumns, {
-      forOutput: true
-    }),
-    __JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__: renderResourceSchemaPropertyLines(writableColumns, {
-      forOutput: false
-    }),
-    __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_RESOURCE_FIELD_META_PUSH_LINES__: renderResourceFieldMetaPushLines(fieldMetaEntries),
-    __JSKIT_CRUD_LIST_CONFIG_LINES__: renderRepositoryListConfigLines(snapshot),
+    __JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__: resourceSchemaPropertyLines,
+    __JSKIT_CRUD_RESOURCE_SEARCH_SCHEMA_LINES__: resourceSearchSchemaLines,
+    __JSKIT_CRUD_RESOURCE_DEFAULT_SORT__: resourceDefaultSortLiteral,
+    __JSKIT_CRUD_RESOURCE_AUTOFILTER__: JSON.stringify(resolvedOwnershipFilter),
+    __JSKIT_CRUD_JSONREST_SCOPE_NAME__: JSON.stringify(toCamelCase(namespace)),
+    __JSKIT_CRUD_JSONREST_AUTOFILTER__: JSON.stringify(resolvedOwnershipFilter),
+    __JSKIT_CRUD_JSONREST_SEARCH_SCHEMA_LINES__: jsonRestSearchSchemaLines,
+    __JSKIT_CRUD_JSONREST_SCHEMA_PROPERTIES__: jsonRestSchemaPropertyLines,
+    __JSKIT_CRUD_JSONREST_DEFAULT_SORT_LINE__: jsonRestDefaultSortLine,
     __JSKIT_CRUD_MIGRATION_COLUMN_LINES__: renderMigrationColumnLines(snapshot),
     __JSKIT_CRUD_MIGRATION_INDEX_LINES__: renderMigrationIndexLines(snapshot),
     __JSKIT_CRUD_MIGRATION_FOREIGN_KEY_LINES__: renderMigrationForeignKeyLines(snapshot),
@@ -2076,13 +2044,10 @@ const __testables = Object.freeze({
   renderMigrationCheckConstraintLines,
   renderMigrationForeignKeyLine,
   resolveScaffoldColumns,
-  renderPropertyAccess,
-  renderResourceFieldSchema,
-  renderInputNormalizer,
-  renderOutputNormalizerExpression,
   resolveCrudGenerationTableName,
   resolveGenerationSnapshot,
-  buildFieldMetaEntries,
+  buildFieldContractEntries,
+  renderCanonicalResourceFieldSchema,
   resolveDefaultCrudSurfaceIdFromAppConfig,
   resolveCrudGenerationSurfaceId,
   resolveCrudSurfaceRequiresWorkspace,
@@ -2090,7 +2055,8 @@ const __testables = Object.freeze({
   renderRoleCatalogPermissionGrants,
   renderActionPermissionSupport,
   renderActionPermissionExpression,
-  renderActionInputValidatorExpression,
+  renderActionInputExpressions,
+  renderRouteValidatorConstants,
   renderRouteParamsValidatorLine,
   renderRouteInputLines
 });
@@ -2098,12 +2064,9 @@ const __testables = Object.freeze({
 export {
   buildTemplateContext,
   resolveScaffoldColumns,
-  renderPropertyAccess,
   resolveGenerationSnapshot,
-  renderResourceFieldSchema,
-  renderInputNormalizer,
-  renderOutputNormalizerExpression,
-  buildFieldMetaEntries,
+  renderCanonicalResourceFieldSchema,
+  buildFieldContractEntries,
   resolveCrudGenerationSurfaceId,
   __testables
 };