@jskit-ai/crud-core 0.1.158 → 0.1.159

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-core",
-  version: "0.1.158",
+  version: "0.1.159",
   kind: "runtime",
   description: "Shared CRUD helpers used by CRUD modules.",
   dependsOn: [
@@ -26,7 +26,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/crud-core": "0.1.158"
+        "@jskit-ai/crud-core": "0.1.159"
       },
       dev: {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-core",
-  "version": "0.1.158",
+  "version": "0.1.159",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -27,15 +27,15 @@
     "./server/routeContracts": "./src/server/routeContracts.js"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime": "0.1.147",
+    "@jskit-ai/database-runtime": "0.1.148",
     "@jskit-ai/http-runtime": "0.1.146",
     "@jskit-ai/kernel": "0.1.147",
     "json-rest-schema": "^1.0.17",
-    "@jskit-ai/realtime": "0.1.144",
+    "@jskit-ai/realtime": "0.1.145",
     "@jskit-ai/resource-crud-core": "0.1.90",
-    "@jskit-ai/shell-web": "0.1.148",
+    "@jskit-ai/shell-web": "0.1.149",
     "@jskit-ai/users-core": "0.1.161",
-    "@jskit-ai/users-web": "0.1.165"
+    "@jskit-ai/users-web": "0.1.166"
   },
   "peerDependencies": {
     "@tanstack/vue-query": "^5.90.5",

package/src/server/repositorySupport.js

@@ -1,6 +1,9 @@
 import {
   normalizeDbRecordId,
-  toDatabaseDateTimeUtc
+  toDatabaseDateTimeUtc,
+  toJsonDate,
+  toJsonTime,
+  toJsonDateTime
 } from "@jskit-ai/database-runtime/shared";
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
@@ -26,6 +29,11 @@ const MAX_LIST_LIMIT = 100;
 const CRUD_WRITE_SERIALIZERS = Object.freeze({
   [CRUD_FIELD_WRITE_SERIALIZER_DATETIME_UTC]: (value) => toDatabaseDateTimeUtc(value)
 });
+const CRUD_OUTPUT_SERIALIZERS = Object.freeze({
+  date: toJsonDate,
+  time: toJsonTime,
+  datetime: toJsonDateTime
+});
 
 function normalizeCrudListCursor(cursor = null, { allowEmpty = true } = {}) {
   if (cursor === undefined || cursor === null) {
@@ -285,10 +293,20 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
   }
 
   const outputRecordIdKeys = [];
+  const outputSerializerByKey = {};
   for (const [key, definition] of Object.entries(outputProperties)) {
     if (definitionIncludesRecordIdType(definition)) {
       outputRecordIdKeys.push(key);
     }
+    const fieldType = resolveFieldDefinitionType(definition);
+    if (Object.hasOwn(CRUD_OUTPUT_SERIALIZERS, fieldType)) {
+      outputSerializerByKey[key] = Object.freeze({
+        type: fieldType,
+        ...(Number.isInteger(definition?.temporalPrecision)
+          ? { temporalPrecision: definition.temporalPrecision }
+          : {})
+      });
+    }
   }
 
   for (const key of writeKeys) {
@@ -318,11 +336,17 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
     virtualOutputKeys: Object.freeze(virtualOutputKeys),
     listSearchColumns: Object.freeze(listSearchColumns),
     parentFilterColumns: Object.freeze(parentFilterColumns),
-    outputRecordIdKeys: Object.freeze(outputRecordIdKeys)
+    outputRecordIdKeys: Object.freeze(outputRecordIdKeys),
+    outputSerializerByKey: Object.freeze(outputSerializerByKey)
   });
 }
 
-function mapRecordRow(row, fieldKeys = [], overrides = {}, { recordIdKeys = [] } = {}) {
+function mapRecordRow(
+  row,
+  fieldKeys = [],
+  overrides = {},
+  { recordIdKeys = [], serializerByKey = {} } = {}
+) {
   if (!row) {
     return null;
   }
@@ -333,6 +357,7 @@ function mapRecordRow(row, fieldKeys = [], overrides = {}, { recordIdKeys = [] }
       .filter(Boolean)
   );
   const mapped = {};
+  const normalizedSerializerByKey = normalizeObjectInput(serializerByKey);
   for (const key of fieldKeys) {
     const normalizedKey = String(key || "").trim();
     const columnName = resolveColumnName(normalizedKey, overrides);
@@ -351,6 +376,21 @@ function mapRecordRow(row, fieldKeys = [], overrides = {}, { recordIdKeys = [] }
       continue;
     }
 
+    const serializerConfig = normalizedSerializerByKey[normalizedKey];
+    const serializerId = normalizeText(
+      typeof serializerConfig === "string" ? serializerConfig : serializerConfig?.type
+    ).toLowerCase();
+    if (serializerId && rawValue != null) {
+      const serializer = CRUD_OUTPUT_SERIALIZERS[serializerId];
+      if (typeof serializer !== "function") {
+        throw new Error(`crudRepository output serializer "${serializerId}" is not supported.`);
+      }
+      mapped[normalizedKey] = serializer(rawValue, {
+        temporalPrecision: serializerConfig?.temporalPrecision
+      });
+      continue;
+    }
+
     mapped[normalizedKey] = rawValue;
   }
   return mapped;

package/src/server/resourceRuntime/index.js

@@ -925,7 +925,10 @@ async function listRecords(runtime, knex, query = {}, callOptions = {}) {
       row,
       runtime.mapping.outputKeys,
       runtime.mapping.columnOverrides,
-      { recordIdKeys: runtime.mapping.outputRecordIdKeys }
+      {
+        recordIdKeys: runtime.mapping.outputRecordIdKeys,
+        serializerByKey: runtime.mapping.outputSerializerByKey
+      }
     );
     if (!mappedRecord) {
       continue;
@@ -1014,7 +1017,10 @@ async function findRecordById(runtime, knex, recordId, callOptions = {}) {
     row,
     runtime.mapping.outputKeys,
     runtime.mapping.columnOverrides,
-    { recordIdKeys: runtime.mapping.outputRecordIdKeys }
+    {
+      recordIdKeys: runtime.mapping.outputRecordIdKeys,
+      serializerByKey: runtime.mapping.outputSerializerByKey
+    }
   );
   if (!mappedRecord) {
     return null;
@@ -1115,7 +1121,10 @@ async function listRecordsByIds(runtime, knex, ids = [], callOptions = {}) {
       row,
       runtime.mapping.outputKeys,
       runtime.mapping.columnOverrides,
-      { recordIdKeys: runtime.mapping.outputRecordIdKeys }
+      {
+        recordIdKeys: runtime.mapping.outputRecordIdKeys,
+        serializerByKey: runtime.mapping.outputSerializerByKey
+      }
     );
     if (!mappedRecord) {
       continue;

package/test/repositorySupport.test.js

@@ -138,6 +138,36 @@ test("mapRecordRow omits keys whose source column is absent", () => {
   });
 });
 
+test("mapRecordRow serializes database temporal values for strict JSON resource output", () => {
+  const row = {
+    service_date: new Date("2026-08-13T23:59:58.123Z"),
+    opening_time: "07:08:09.123456",
+    scheduled_at: "2026-08-13 07:08:09.123456"
+  };
+  const mapped = mapRecordRow(
+    row,
+    ["serviceDate", "openingTime", "scheduledAt"],
+    {
+      serviceDate: "service_date",
+      openingTime: "opening_time",
+      scheduledAt: "scheduled_at"
+    },
+    {
+      serializerByKey: {
+        serviceDate: "date",
+        openingTime: "time",
+        scheduledAt: "datetime"
+      }
+    }
+  );
+
+  assert.deepEqual(mapped, {
+    serviceDate: "2026-08-13",
+    openingTime: "07:08:09.123456",
+    scheduledAt: "2026-08-13T07:08:09.123456Z"
+  });
+});
+
 test("buildWritePayload respects defined keys", () => {
   const payload = buildWritePayload(
     { foo: "bar", missing: true },
@@ -574,6 +604,36 @@ test("deriveRepositoryMappingFromResource tracks writable column-backed write se
     scheduledAt: "datetime-utc",
     archivedAt: "datetime-utc"
   });
+  assert.deepEqual(mapping.outputSerializerByKey, {
+    scheduledAt: { type: "datetime" },
+    archivedAt: { type: "datetime" }
+  });
+});
+
+test("deriveRepositoryMappingFromResource tracks JSON temporal output serializers", () => {
+  const resource = {
+    operations: {
+      view: {
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          serviceDate: { type: "date", required: true },
+          openingTime: { type: "time", required: true },
+          scheduledAt: { type: "dateTime", temporalPrecision: 3, required: true }
+        })
+      },
+      create: {
+        body: createOperationSchemaDefinition({}, "create")
+      }
+    }
+  };
+
+  const mapping = deriveRepositoryMappingFromResource(resource);
+
+  assert.deepEqual(mapping.outputSerializerByKey, {
+    serviceDate: { type: "date" },
+    openingTime: { type: "time" },
+    scheduledAt: { type: "datetime", temporalPrecision: 3 }
+  });
 });
 
 test("deriveRepositoryMappingFromResource keeps explicit storage.writeSerializer metadata", () => {

package/test/resourceRuntime.test.js

@@ -499,6 +499,64 @@ test("list uses resource table and id defaults", async () => {
   assert.ok(calls.some((call) => call[0] === "where" && call[1] === "contact_id" && call[2] === ">" && call[3] === "2"));
 });
 
+test("list converts database temporal values before strict resource validation", async () => {
+  const resource = {
+    namespace: "appointments",
+    tableName: "appointments",
+    operations: {
+      view: {
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true
+            },
+            serviceDate: {
+              type: "date",
+              required: true
+            },
+            openingTime: {
+              type: "time",
+              required: true
+            },
+            scheduledAt: {
+              type: "dateTime",
+              required: true
+            }
+          }),
+          mode: "replace"
+        }
+      },
+      create: {
+        body: {
+          schema: createSchema({}),
+          mode: "create"
+        }
+      }
+    }
+  };
+  const { knex } = createKnexDouble([
+    {
+      id: 3,
+      service_date: new Date("2026-08-13T23:59:58.123Z"),
+      opening_time: "07:08:09.123456",
+      scheduled_at: "2026-08-13 07:08:09.123456"
+    }
+  ]);
+  const repository = createCrudResourceRuntime(resource, knex);
+
+  const result = await repository.list();
+
+  assert.deepEqual(result.items, [
+    {
+      id: "3",
+      serviceDate: "2026-08-13",
+      openingTime: "07:08:09.123456",
+      scheduledAt: "2026-08-13T07:08:09.123456Z"
+    }
+  ]);
+});
+
 test("list respects bound list config", async () => {
   const { knex, calls } = createKnexDouble([
     { contact_id: 3, first_name: "Tony" },