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

package/test/buildTemplateContext.test.js

@@ -285,13 +285,15 @@ test("buildReplacementsFromSnapshot builds deterministic template replacement pa
     /buildWorkspaceInputFromRouteParams/
   );
   assert.equal(replacements.__JSKIT_CRUD_ROUTE_SURFACE_REQUIRES_WORKSPACE__, "true");
-  assert.equal(
-    replacements.__JSKIT_CRUD_LIST_ACTION_INPUT_VALIDATOR__,
-    "[workspaceSlugParamsValidator, listCursorPaginationQueryValidator, listSearchQueryValidator, listParentFilterQueryValidator, lookupIncludeQueryValidator]"
-  );
+  assert.match(replacements.__JSKIT_CRUD_LIST_ACTION_INPUT__, /composeSchemaDefinitions\(\[/);
+  assert.match(replacements.__JSKIT_CRUD_LIST_ACTION_INPUT__, /workspaceSlugParamsValidator,/);
   assert.equal(
     replacements.__JSKIT_CRUD_VIEW_ROUTE_PARAMS_VALIDATOR_LINE__,
-    "      paramsValidator: [routeParamsValidator, recordIdParamsValidator],"
+    "      params: recordRouteParamsValidator,"
+  );
+  assert.match(
+    replacements.__JSKIT_CRUD_ROUTE_VALIDATOR_CONSTANTS__,
+    /const recordRouteParamsValidator = composeSchemaDefinitions\(/
   );
   assert.match(
     replacements.__JSKIT_CRUD_ROLE_CATALOG_PERMISSION_GRANTS__,
@@ -303,42 +305,36 @@ test("buildReplacementsFromSnapshot builds deterministic template replacement pa
   );
   assert.match(replacements.__JSKIT_CRUD_MIGRATION_COLUMN_LINES__, /table\.bigIncrements\("id"\)/);
   assert.match(replacements.__JSKIT_CRUD_MIGRATION_COLUMN_LINES__, /table\.string\("first_name", 160\)/);
-  assert.equal(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, "");
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__, /updatedAt: Type\.String/);
+  assert.equal(Object.hasOwn(replacements, "__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__"), false);
+  assert.equal(Object.hasOwn(replacements, "__JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__"), false);
+  assert.equal(Object.hasOwn(replacements, "__JSKIT_CRUD_RESOURCE_PATCH_SCHEMA_PROPERTIES__"), false);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /updatedAt: \{/);
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__,
-    /id: recordIdSchema,/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /firstName: \{[\s\S]*type: "string",[\s\S]*maxLength: 160,[\s\S]*required: true,[\s\S]*search: true,[\s\S]*output: \{ required: true \},[\s\S]*create: \{ required: true \},[\s\S]*patch: \{ required: false \}[\s\S]*\},/s
   );
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__, /firstName: Type\.String/);
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
-    /normalizeIfInSource\(source, normalized, "firstName", normalizeText\);/
-  );
-  assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
-    /\(value\) =>/
-  );
-  assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
-    /value == null/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /createdAt: \{[\s\S]*type: "dateTime",[\s\S]*default: "now\(\)",[\s\S]*storage: \{ writeSerializer: "datetime-utc" \}[\s\S]*output: \{ required: true \}[\s\S]*\},/s
   );
+  assert.doesNotMatch(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /^\s*id:\s*\{/m);
+  assert.doesNotMatch(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /pattern: RECORD_ID_PATTERN/);
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__,
-    /firstName: normalizeIfPresent\(source\.firstName, normalizeText\),/
+    replacements.__JSKIT_CRUD_JSONREST_SCHEMA_PROPERTIES__,
+    /createdAt: \{[\s\S]*storage: \{ serialize: serializeNullableDateTime \}[\s\S]*\},/s
   );
-  assert.match(
-    replacements.__JSKIT_CRUD_LIST_CONFIG_LINES__,
-    /orderBy: \[\s+{\s+column: "created_at",\s+direction: "desc"\s+}\s+\]/s
+  assert.doesNotMatch(
+    replacements.__JSKIT_CRUD_JSONREST_SCHEMA_PROPERTIES__,
+    /workspaceId: \{[^}]*storage: \{/s
   );
-  assert.match(
-    replacements.__JSKIT_CRUD_LIST_CONFIG_LINES__,
-    /\/\/ searchColumns: \["name"\],\s+orderBy:/s
+  assert.doesNotMatch(
+    replacements.__JSKIT_CRUD_JSONREST_SCHEMA_PROPERTIES__,
+    /howManyCars: \{[^}]*storage: \{/s
   );
   assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__,
-    /== null \?/
+    replacements.__JSKIT_CRUD_JSONREST_SCHEMA_PROPERTIES__,
+    /^\s*id:\s*\{/m
   );
-  assert.equal(replacements.__JSKIT_CRUD_RESOURCE_CREATE_REQUIRED_FIELDS__, "[\"firstName\"]");
   assert.equal(replacements.__JSKIT_CRUD_MIGRATION_FOREIGN_KEY_LINES__, "");
 });
 
@@ -364,14 +360,12 @@ test("buildReplacementsFromSnapshot omits named permissions and role grants when
   assert.equal(replacements.__JSKIT_CRUD_ACTION_WORKSPACE_VALIDATOR_IMPORT__, "");
   assert.equal(replacements.__JSKIT_CRUD_ROUTE_WORKSPACE_SUPPORT_IMPORTS__, "");
   assert.equal(replacements.__JSKIT_CRUD_ROUTE_SURFACE_REQUIRES_WORKSPACE__, "false");
-  assert.equal(
-    replacements.__JSKIT_CRUD_CREATE_ACTION_INPUT_VALIDATOR__,
-    "{ payload: resource.operations.create.bodyValidator }"
-  );
+  assert.equal(replacements.__JSKIT_CRUD_CREATE_ACTION_INPUT__, "resource.operations.create.body");
+  assert.equal(replacements.__JSKIT_CRUD_DELETE_ACTION_INPUT__, "recordIdParamsValidator");
   assert.equal(replacements.__JSKIT_CRUD_LIST_ROUTE_PARAMS_VALIDATOR_LINE__, "");
   assert.equal(
     replacements.__JSKIT_CRUD_VIEW_ROUTE_PARAMS_VALIDATOR_LINE__,
-    "      paramsValidator: recordIdParamsValidator,"
+    "      params: recordRouteParamsValidator,"
   );
   assert.equal(
     replacements.__JSKIT_CRUD_VIEW_ROUTE_INPUT_LINES__,
@@ -469,17 +463,14 @@ test("buildReplacementsFromSnapshot omits default list ordering when created_at
   const snapshot = createSnapshot({
     hasCreatedAtColumn: false
   });
-  const replacements = __testables.buildReplacementsFromSnapshot({
+  __testables.buildReplacementsFromSnapshot({
     namespace: "contacts",
     snapshot,
     resolvedOwnershipFilter: "workspace_user"
   });
-
-  assert.doesNotMatch(replacements.__JSKIT_CRUD_LIST_CONFIG_LINES__, /orderBy/);
-  assert.match(replacements.__JSKIT_CRUD_LIST_CONFIG_LINES__, /searchColumns/);
 });
 
-test("buildReplacementsFromSnapshot renders append-only field meta entries from foreign keys", () => {
+test("buildReplacementsFromSnapshot renders inline field relation metadata from foreign keys", () => {
   const snapshot = {
     ...createSnapshot(),
     columns: Object.freeze([
@@ -524,17 +515,15 @@ test("buildReplacementsFromSnapshot renders append-only field meta entries from
     resolvedOwnershipFilter: "workspace_user"
   });
 
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /RESOURCE_FIELD_META\.push\(\{/);
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /key: "vetId"/);
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /namespace: "customer-categories"/);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /vetId: \{/);
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__,
-    /formControl: "autocomplete" \/\/ or "select"/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /relation: \{ kind: "lookup", namespace: "customer-categories", valueKey: "id" \}.*belongsTo: "customerCategories".*as: "vet".*ui: \{ formControl: "autocomplete" \}/s
   );
   assert.match(replacements.__JSKIT_CRUD_MIGRATION_FOREIGN_KEY_LINES__, /table\.foreign\(\["vet_id"\]/);
 });
 
-test("buildReplacementsFromSnapshot renders enum field meta options as select controls", () => {
+test("buildReplacementsFromSnapshot renders inline enum field ui options as select controls", () => {
   const baseSnapshot = createSnapshot({
     hasWorkspaceIdColumn: false,
     hasUserIdColumn: false
@@ -569,11 +558,11 @@ test("buildReplacementsFromSnapshot renders enum field meta options as select co
     resolvedOwnershipFilter: "public"
   });
 
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /key: "temperament"/);
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /formControl: "select"/);
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /options: \[/);
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /"value": "friendly_excitable"/);
-  assert.match(replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__, /"label": "Friendly Excitable"/);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /temperament: \{/);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /ui: \{ formControl: "select"/);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /options: \[/);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /"value":"friendly_excitable"/);
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__, /"label":"Friendly Excitable"/);
 });
 
 test("renderMigrationColumnLine ignores SQL NULL string defaults", () => {
@@ -738,7 +727,7 @@ test("buildReplacementsFromSnapshot preserves custom collations, hash unique ind
   );
 });
 
-test("resolveScaffoldColumns derives resource numeric bounds from check constraints", () => {
+test("resolveScaffoldColumns derives canonical resource numeric bounds from check constraints", () => {
   const snapshot = createSnapshot({
     tableName: "batch_receivals",
     hasWorkspaceIdColumn: false,
@@ -863,25 +852,25 @@ test("resolveScaffoldColumns derives resource numeric bounds from check constrai
   const moistureLevel = scaffoldColumns.find((column) => column.name === "moisture_level");
   const severity = scaffoldColumns.find((column) => column.name === "severity");
 
-  assert.equal(
-    __testables.renderResourceFieldSchema(inputWeight),
-    "Type.Number({ minimum: 0.001 })"
+  assert.match(
+    __testables.renderCanonicalResourceFieldSchema(inputWeight),
+    /type: "number".*min: 0.001.*required: true.*search: true.*create: \{ required: true \}/s
   );
-  assert.equal(
-    __testables.renderResourceFieldSchema(batchedDailySequence),
-    "Type.Integer({ minimum: 1 })"
+  assert.match(
+    __testables.renderCanonicalResourceFieldSchema(batchedDailySequence),
+    /type: "integer".*min: 1.*required: true.*search: true.*create: \{ required: true \}/s
   );
-  assert.equal(
-    __testables.renderResourceFieldSchema(moistureLevel),
-    "Type.Union([Type.Number({ minimum: 0, maximum: 100 }), Type.Null()])"
+  assert.match(
+    __testables.renderCanonicalResourceFieldSchema(moistureLevel),
+    /type: "number".*min: 0.*max: 100.*nullable: true.*search: true.*create: \{ required: false \}/s
   );
-  assert.equal(
-    __testables.renderResourceFieldSchema(severity),
-    "Type.Union([Type.Integer({ minimum: 1, maximum: 10 }), Type.Null()])"
+  assert.match(
+    __testables.renderCanonicalResourceFieldSchema(severity),
+    /type: "integer".*min: 1.*max: 10.*nullable: true.*search: true.*create: \{ required: false \}/s
   );
 });
 
-test("buildReplacementsFromSnapshot normalizes nullable temporal inputs without invalid date errors", () => {
+test("buildReplacementsFromSnapshot renders canonical nullable temporal fields without invalid date errors", () => {
   const snapshot = createSnapshot({
     hasWorkspaceIdColumn: false,
     hasUserIdColumn: false
@@ -951,96 +940,107 @@ test("buildReplacementsFromSnapshot normalizes nullable temporal inputs without
   });
 
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
-    /normalizeIfInSource\(source, normalized, "scheduledAt", \(value\) => \{ const normalized = normalizeText\(value\); return normalized \? toIsoString\(normalized\) : null; \}\);/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /scheduledAt: \{[\s\S]*type: "dateTime",[\s\S]*nullable: true,[\s\S]*storage: \{ writeSerializer: "datetime-utc" \},[\s\S]*create: \{ required: false \}[\s\S]*\},/s
   );
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
-    /normalizeIfInSource\(source, normalized, "birthDate", \(value\) => \{ const normalized = normalizeText\(value\); return normalized \? toIsoString\(normalized\)\.slice\(0, 10\) : null; \}\);/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /birthDate: \{[\s\S]*type: "date",[\s\S]*nullable: true,[\s\S]*create: \{ required: false \}[\s\S]*\},/s
   );
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
-    /normalizeIfInSource\(source, normalized, "preferredTime", \(value\) => \{ const normalized = normalizeText\(value\); return normalized \|\| null; \}\);/
-  );
-  assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__,
-    /writeSerializer: "datetime-utc"/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /preferredTime: \{[\s\S]*type: "time",[\s\S]*nullable: true,[\s\S]*create: \{ required: false \}[\s\S]*\},/s
   );
 });
 
-test("crud repository template defines explicit one-line CRUD methods over repository primitives", async () => {
+test("crud repository template defines a json-rest-api adapter over the injected internal host", async () => {
   const testDirectory = path.dirname(fileURLToPath(import.meta.url));
   const templatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "repository.js");
   const templateSource = await readFile(templatePath, "utf8");
-  assert.match(
-    templateSource,
-    /from "@jskit-ai\/crud-core\/server\/resourceRuntime";/
-  );
-  assert.match(templateSource, /import \{ LIST_CONFIG \} from "\.\/listConfig\.js";/);
-  assert.match(templateSource, /const REPOSITORY_CONFIG = Object\.freeze\(\{/);
-  assert.match(templateSource, /const resourceRuntime = createCrudResourceRuntime\(resource, knex, \{/);
-  assert.match(templateSource, /\.\.\.options,/);
-  assert.match(templateSource, /\.\.\.REPOSITORY_CONFIG/);
-  assert.match(templateSource, /return resourceRuntime\.list\(query, callOptions\);/);
-  assert.match(templateSource, /return resourceRuntime\.findById\(recordId, callOptions\);/);
-  assert.match(templateSource, /return resourceRuntime\.listByIds\(ids, callOptions\);/);
-  assert.match(templateSource, /return resourceRuntime\.listByForeignIds\(ids, foreignKey, callOptions\);/);
-  assert.match(templateSource, /return resourceRuntime\.create\(payload, callOptions\);/);
-  assert.match(templateSource, /return resourceRuntime\.updateById\(recordId, patch, callOptions\);/);
-  assert.match(templateSource, /return resourceRuntime\.deleteById\(recordId, callOptions\);/);
-  assert.match(templateSource, /async function listByForeignIds\(ids = \[\], foreignKey = "", callOptions = \{\}\) \{/);
-  assert.match(templateSource, /withTransaction: resourceRuntime\.withTransaction/);
+  assert.doesNotMatch(templateSource, /from "@jskit-ai\/http-runtime\/shared";/);
+  assert.match(templateSource, /returnNullWhenJsonRestResourceMissing/);
+  assert.match(templateSource, /return api\.resources\.\$\{option:namespace\|camel\}\.query\(/);
+  assert.match(templateSource, /return returnNullWhenJsonRestResourceMissing\(\(\) =>\s+api\.resources\.\$\{option:namespace\|camel\}\.get\(/s);
+  assert.match(templateSource, /return api\.resources\.\$\{option:namespace\|camel\}\.post\(/);
+  assert.match(templateSource, /return returnNullWhenJsonRestResourceMissing\(\(\) =>\s+api\.resources\.\$\{option:namespace\|camel\}\.patch\(/s);
+  assert.match(templateSource, /return returnNullWhenJsonRestResourceMissing\(async \(\) => \{\s+await api\.resources\.\$\{option:namespace\|camel\}\.delete\(/s);
+  assert.match(templateSource, /createJsonRestContext\(options\?\.context \|\| null\)/);
+  assert.match(templateSource, /buildJsonRestQueryParams\(RESOURCE_TYPE, query\)/);
+  assert.match(templateSource, /createJsonApiInputRecord\(RESOURCE_TYPE, payload\)/);
+  assert.doesNotMatch(templateSource, /function toJsonRestContext\(context = null\)/);
+  assert.doesNotMatch(templateSource, /function normalizeArrayInput\(value\)/);
+  assert.doesNotMatch(templateSource, /function buildJsonRestQueryParams\(query = \{\}/);
+  assert.doesNotMatch(templateSource, /function createJsonApiInputRecord\(attributes = \{\}/);
+  assert.doesNotMatch(templateSource, /normalizeVisibilityContext/);
+  assert.match(templateSource, /withTransaction,/);
   assert.match(templateSource, /return Object\.freeze\(\{/);
-  assert.doesNotMatch(templateSource, /crudRepositoryList/);
+  assert.doesNotMatch(templateSource, /createCrudResourceRuntime|resourceRuntime\./);
 });
 
-test("crud actions and routes templates share LIST_CONFIG for cursor validation", async () => {
+test("crud provider template derives json-rest host options directly from the shared resource", async () => {
+  const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+  const templatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "CrudProvider.js");
+  const templateSource = await readFile(templatePath, "utf8");
+
+  assert.match(templateSource, /import \{ createCrudJsonApiServiceEvents \} from "@jskit-ai\/crud-core\/server\/serviceEvents";/);
+  assert.match(templateSource, /createJsonRestResourceScopeOptions/);
+  assert.match(templateSource, /import \{ createService \} from "\.\/service\.js";/);
+  assert.doesNotMatch(templateSource, /serviceEvents\s*\}\s*from "\.\/service\.js";/);
+  assert.match(templateSource, /import \{ resource \} from "\.\.\/shared\/\$\{option:namespace\|singular\|camel\}Resource\.js";/);
+  assert.doesNotMatch(templateSource, /normalizeRecordId/);
+  assert.match(templateSource, /toDatabaseDateTimeUtc/);
+  assert.doesNotMatch(templateSource, /register\$\{option:namespace\|pascal\}JsonRestResources/);
+  assert.match(templateSource, /const baseServiceEvents = createCrudJsonApiServiceEvents\(CRUD_MODULE_CONFIG\.namespace\);/);
+  assert.match(templateSource, /const serviceEvents = \{\s+\.\.\.baseServiceEvents\s+\};/s);
+  assert.match(templateSource, /const api = app\.make\(INTERNAL_JSON_REST_API\);/);
+  assert.match(templateSource, /await addResourceIfMissing\(\s*api,\s*__JSKIT_CRUD_JSONREST_SCOPE_NAME__,\s*createJsonRestResourceScopeOptions\(resource,/s);
+});
+
+test("crud actions and routes templates derive cursor validation and route contracts from the shared resource", async () => {
   const testDirectory = path.dirname(fileURLToPath(import.meta.url));
   const actionsTemplatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "actions.js");
   const registerRoutesTemplatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "registerRoutes.js");
-  const listConfigTemplatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "listConfig.js");
 
   const actionsTemplateSource = await readFile(actionsTemplatePath, "utf8");
   const registerRoutesTemplateSource = await readFile(registerRoutesTemplatePath, "utf8");
-  const listConfigTemplateSource = await readFile(listConfigTemplatePath, "utf8");
 
   assert.match(actionsTemplateSource, /createCrudCursorPaginationQueryValidator/);
-  assert.match(actionsTemplateSource, /import \{ LIST_CONFIG \} from "\.\/listConfig\.js";/);
-  assert.match(actionsTemplateSource, /const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator\(LIST_CONFIG\);/);
+  assert.match(actionsTemplateSource, /import \{ resource \} from "\.\.\/shared\/\$\{option:namespace\|singular\|camel\}Resource\.js";/);
+  assert.match(actionsTemplateSource, /const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator\(\{\s+orderBy: resource\.defaultSort\s+\}\);/s);
   assert.match(actionsTemplateSource, /__JSKIT_CRUD_ACTION_PERMISSION_SUPPORT__/);
   assert.match(actionsTemplateSource, /__JSKIT_CRUD_LIST_ACTION_PERMISSION__/);
+  assert.match(actionsTemplateSource, /output: null,/);
   assert.doesNotMatch(actionsTemplateSource, /ACTIONS_REQUIRE_NAMED_PERMISSIONS/);
   assert.doesNotMatch(actionsTemplateSource, /createActionPermission/);
-  assert.match(registerRoutesTemplateSource, /createCrudCursorPaginationQueryValidator/);
-  assert.match(registerRoutesTemplateSource, /import \{ LIST_CONFIG \} from "\.\/listConfig\.js";/);
-  assert.match(registerRoutesTemplateSource, /const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator\(LIST_CONFIG\);/);
-  assert.match(listConfigTemplateSource, /const LIST_CONFIG = Object\.freeze\(\{/);
-  assert.match(listConfigTemplateSource, /__JSKIT_CRUD_LIST_CONFIG_LINES__/);
+  assert.match(registerRoutesTemplateSource, /createCrudJsonApiRouteContracts/);
+  assert.match(registerRoutesTemplateSource, /const \{\s+listRouteContract,\s+viewRouteContract,\s+createRouteContract,\s+updateRouteContract,\s+deleteRouteContract,\s+recordRouteParamsValidator\s+\} = createCrudJsonApiRouteContracts\(\{/s);
+  assert.match(registerRoutesTemplateSource, /resource__JSKIT_CRUD_ROUTE_CONTRACTS_RESOURCE_ARGS__/);
+  assert.doesNotMatch(registerRoutesTemplateSource, /wrapResponse/);
+  assert.match(registerRoutesTemplateSource, /reply\.code\(204\)\.send\(response\);/);
+  assert.doesNotMatch(registerRoutesTemplateSource, /withStandardErrorResponses/);
 });
 
-test("crud service template defines explicit service methods over shared service primitives and preserves overridable default events", async () => {
+test("crud service template preserves JSON:API output and emits entity ids from resource documents", async () => {
   const testDirectory = path.dirname(fileURLToPath(import.meta.url));
   const templatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "service.js");
   const templateSource = await readFile(templatePath, "utf8");
 
-  assert.match(
-    templateSource,
-    /from "@jskit-ai\/crud-core\/server\/serviceEvents";/
-  );
-  assert.match(
-    templateSource,
-    /from "@jskit-ai\/crud-core\/server\/serviceMethods";/
-  );
-  assert.match(templateSource, /const serviceRuntime = createCrudServiceRuntime\(resource,/);
-  assert.match(templateSource, /const baseServiceEvents = createCrudServiceEvents\(resource,/);
-  assert.match(templateSource, /const serviceEvents = Object\.freeze\(\{/);
-  assert.match(templateSource, /createRecord: \[\.\.\.baseServiceEvents\.createRecord\],/);
-  assert.match(templateSource, /function createService\(\{ \$\{option:namespace\|camel\}Repository, fieldAccess = DEFAULT_FIELD_ACCESS \} = \{\}\)/);
-  assert.match(templateSource, /async function listRecords\(query = \{\}, options = \{\}\)/);
-  assert.match(templateSource, /return crudServiceListRecords\(serviceRuntime, \$\{option:namespace\|camel\}Repository, fieldAccess, query, options\);/);
-  assert.match(templateSource, /async function updateRecord\(recordId, payload = \{\}, options = \{\}\)/);
-  assert.match(templateSource, /return crudServiceUpdateRecord\(serviceRuntime, \$\{option:namespace\|camel\}Repository, fieldAccess, recordId, payload, options\);/);
+  assert.doesNotMatch(templateSource, /crudNamespaceSupport/);
+  assert.doesNotMatch(templateSource, /serviceEvents/);
+  assert.doesNotMatch(templateSource, /recordChangedEventName/);
+  assert.doesNotMatch(templateSource, /resolveJsonApiResultRecordId/);
+  assert.doesNotMatch(templateSource, /entityId:/);
+  assert.match(templateSource, /function return404IfNotFound\(document = null\) \{/);
+  assert.match(templateSource, /throw new AppError\(404, "Document not found\."\);/);
+  assert.match(templateSource, /function createService\(\{ \$\{option:namespace\|camel\}Repository \} = \{\}\)/);
+  assert.match(templateSource, /throw new TypeError\("createService requires \$\{option:namespace\|camel\}Repository\."\);/);
+  assert.match(templateSource, /returnJsonApiDocument/);
+  assert.match(templateSource, /async function queryDocuments\(query = \{\}, options = \{\}\)/);
+  assert.match(templateSource, /returnJsonApiDocument\(await \$\{option:namespace\|camel\}Repository\.queryDocuments\(query, \{/);
+  assert.match(templateSource, /async function patchDocumentById\(recordId, payload = \{\}, options = \{\}\)/);
+  assert.match(templateSource, /returnJsonApiDocument\(return404IfNotFound\(await \$\{option:namespace\|camel\}Repository\.patchDocumentById\(recordId, payload, \{/);
   assert.match(templateSource, /return Object\.freeze\(\{/);
+  assert.match(templateSource, /export \{ createService \};/);
 });
 
 test("crud generator renders time columns with html-time-compatible schemas", async () => {
@@ -1050,16 +1050,12 @@ test("crud generator renders time columns with html-time-compatible schemas", as
 
   assert.match(
     templateSource,
-    /NULLABLE_HTML_TIME_STRING_SCHEMA/
+    /type: "time"/
   );
-  assert.match(
-    templateSource,
-    /HTML_TIME_STRING_SCHEMA/
-  );
-  assert.doesNotMatch(templateSource, /format: "time"/);
+  assert.doesNotMatch(templateSource, /HTML_TIME_STRING_SCHEMA|NULLABLE_HTML_TIME_STRING_SCHEMA/);
 });
 
-test("buildReplacementsFromSnapshot uses shared framework time schemas in generated resources", () => {
+test("buildReplacementsFromSnapshot renders canonical nullable time fields", () => {
   const snapshot = createSnapshot({
     tableName: "opening_hours"
   });
@@ -1090,28 +1086,12 @@ test("buildReplacementsFromSnapshot uses shared framework time schemas in genera
   });
 
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__,
-    /(^|\n)\s*NULLABLE_HTML_TIME_STRING_SCHEMA(,|\n)/m
-  );
-  assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__,
-    /(^|\n)\s*HTML_TIME_STRING_SCHEMA(,|\n)/m
-  );
-  assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__,
-    /fromTime: NULLABLE_HTML_TIME_STRING_SCHEMA/
-  );
-  assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__,
-    /fromTime: NULLABLE_HTML_TIME_STRING_SCHEMA/
-  );
-  assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__,
-    /Type\.String\(\{ pattern:/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /fromTime: \{[\s\S]*type: "time",[\s\S]*nullable: true,[\s\S]*output: \{ required: true \},[\s\S]*create: \{ required: false \},[\s\S]*patch: \{ required: false \}[\s\S]*\},/s
   );
 });
 
-test("buildReplacementsFromSnapshot imports only the non-nullable time schema when nullable time fields are absent", () => {
+test("buildReplacementsFromSnapshot renders canonical non-nullable time fields", () => {
   const snapshot = createSnapshot({
     tableName: "opening_hours"
   });
@@ -1142,74 +1122,30 @@ test("buildReplacementsFromSnapshot imports only the non-nullable time schema wh
   });
 
   assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__,
-    /(^|\n)\s*HTML_TIME_STRING_SCHEMA(,|\n)/m
-  );
-  assert.doesNotMatch(
-    replacements.__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__,
-    /(^|\n)\s*NULLABLE_HTML_TIME_STRING_SCHEMA(,|\n)/m
-  );
-  assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__,
-    /fromTime: HTML_TIME_STRING_SCHEMA/
+    replacements.__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__,
+    /fromTime: \{[\s\S]*type: "time",[\s\S]*required: true,[\s\S]*output: \{ required: true \},[\s\S]*create: \{ required: true \},[\s\S]*patch: \{ required: false \}[\s\S]*\},/s
   );
-  assert.match(
-    replacements.__JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__,
-    /fromTime: HTML_TIME_STRING_SCHEMA/
-  );
-});
-
-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 () => {
+test("crud provider template injects the shared internal json-rest-api host and registers local resources at boot", async () => {
   const testDirectory = path.dirname(fileURLToPath(import.meta.url));
   const templatePath = path.resolve(testDirectory, "..", "templates", "src", "local-package", "server", "CrudProvider.js");
   const templateSource = await readFile(templatePath, "utf8");
 
   assert.match(
     templateSource,
-    /from "@jskit-ai\/crud-core\/server\/lookups";/
+    /from "@jskit-ai\/json-rest-api-core\/server\/jsonRestApiHost";/
   );
-  assert.match(templateSource, /resolveLookup: createCrudLookupResolver\(scope\)/);
   assert.match(
     templateSource,
-    /return createCrudLookup\(scope\.make\("repository\.\$\{option:namespace\|snake\}"\), \{\s*ownershipFilter: crudPolicy\.ownershipFilter\s*\}\);/
+    /const api = scope\.make\(INTERNAL_JSON_REST_API\);/
   );
+  assert.match(templateSource, /return createRepository\(\{\s*api,\s*knex\s*\}\);/s);
+  assert.match(templateSource, /await addResourceIfMissing\(\s*api,\s*__JSKIT_CRUD_JSONREST_SCOPE_NAME__,\s*createJsonRestResourceScopeOptions\(resource,/s);
+  assert.doesNotMatch(templateSource, /register\$\{option:namespace\|pascal\}JsonRestResources/);
   assert.match(
     templateSource,
     /routeSurfaceRequiresWorkspace: crudPolicy\.surfaceDefinition\.requiresWorkspace === true,/
   );
-  assert.doesNotMatch(templateSource, /normalizePathname\(relation\.apiPath\)/);
+  assert.doesNotMatch(templateSource, /createCrudLookup|lookup\.\$\{option:namespace\|snake\}/);
 });

package/test/crudResource.test.js

@@ -1,47 +1,42 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { crudResource } from "../src/shared/crud/crudResource.js";
 
-test("crudResource normalizes create payload", () => {
-  const normalized = crudResource.operations.create.bodyValidator.normalize({
+test("crudResource normalizes create payload through schema validation", async () => {
+  const normalized = await validateSchemaPayload(crudResource.operations.create.body, {
     textField: "  Example text  ",
     dateField: "2026-03-11",
     numberField: "42.5"
-  });
+  }, { phase: "input" });
 
-  assert.deepEqual(normalized, {
-    textField: "Example text",
-    dateField: "2026-03-11T00:00:00.000Z",
-    numberField: 42.5
-  });
+  assert.equal(normalized.textField, "Example text");
+  assert.equal(normalized.numberField, 42.5);
+  assert.ok(normalized.dateField instanceof Date);
+  assert.equal(normalized.dateField.toISOString(), "2026-03-11T00:00:00.000Z");
 });
 
-test("crudResource normalizes list output", () => {
-  const normalized = crudResource.operations.list.outputValidator.normalize({
-    items: [
-      {
-        id: "7",
-        textField: " Example text ",
-        dateField: "2026-03-10",
-        numberField: "99",
-        createdAt: "2026-03-11 00:00:00.000",
-        updatedAt: "2026-03-11 00:00:00.000"
-      }
-    ],
-    nextCursor: " 8 "
-  });
+test("crudResource normalizes record output through schema validation", async () => {
+  const normalized = await validateSchemaPayload(crudResource.operations.view.output, {
+    id: 7,
+    textField: " Example text ",
+    dateField: "2026-03-10",
+    numberField: "99",
+    createdAt: "2026-03-11 00:00:00.000",
+    updatedAt: "2026-03-11 00:00:00.000"
+  }, { phase: "output" });
 
-  assert.equal(normalized.items[0].id, "7");
-  assert.equal(normalized.items[0].textField, "Example text");
-  assert.equal(normalized.items[0].dateField, "2026-03-10T00:00:00.000Z");
-  assert.equal(normalized.items[0].numberField, 99);
-  assert.match(normalized.items[0].createdAt, /T/);
-  assert.match(normalized.items[0].updatedAt, /T/);
-  assert.equal(normalized.nextCursor, "8");
+  assert.equal(normalized.id, "7");
+  assert.equal(normalized.textField, "Example text");
+  assert.ok(normalized.dateField instanceof Date);
+  assert.equal(normalized.dateField.toISOString(), "2026-03-10T00:00:00.000Z");
+  assert.equal(normalized.numberField, 99);
+  assert.ok(normalized.createdAt instanceof Date);
+  assert.ok(normalized.updatedAt instanceof Date);
 });
 
 test("crudResource list operation exposes output validator only", () => {
-  assert.equal(typeof crudResource.operations.list.outputValidator?.normalize, "function");
-  assert.equal(crudResource.operations.list.inputValidator, undefined);
+  assert.equal(crudResource.operations.list.output?.normalize, undefined);
+  assert.equal(crudResource.operations.list.input, undefined);
   assert.deepEqual(crudResource.operations.list.realtime?.events, ["crud.record.changed"]);
 });