@jskit-ai/json-rest-api-core 0.1.91 → 0.1.92

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/json-rest-api-core",
-  version: "0.1.91",
+  version: "0.1.92",
   kind: "runtime",
   description: "Shared internal json-rest-api host runtime with autofilter, query-projection, and row-policy support.",
   dependsOn: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/json-rest-api-core",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -11,6 +11,6 @@
   "dependencies": {
     "hooked-api": "1.x.x",
     "json-rest-api": "^1.0.27",
-    "@jskit-ai/kernel": "0.1.146"
+    "@jskit-ai/kernel": "0.1.147"
   }
 }

package/src/server/jsonRestApiHost.js

@@ -54,6 +54,8 @@ const JSON_REST_RESERVED_QUERY_KEYS = Object.freeze(new Set([
   "fields"
 ]));
 const JSON_REST_CALENDAR_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+const JSON_REST_DATE_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u;
+const JSON_REST_DATABASE_UTC_DATE_TIME_PATTERN = /^(\d{4}-\d{2}-\d{2}) ((?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?)$/u;
 
 function isPlainJsonRestObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -139,6 +141,20 @@ function serializeJsonRestCalendarDate(value) {
   return canonical;
 }
 
+function resolveCanonicalDateTime(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  }
+
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (JSON_REST_DATE_TIME_PATTERN.test(normalized)) {
+    return normalized;
+  }
+
+  const databaseMatch = JSON_REST_DATABASE_UTC_DATE_TIME_PATTERN.exec(normalized);
+  return databaseMatch ? `${databaseMatch[1]}T${databaseMatch[2]}Z` : "";
+}
+
 function applyJsonRestCalendarDateWriteSerializers(scopeOptions = {}) {
   const schema = normalizeJsonRestObject(scopeOptions.schema);
   for (const fieldDefinition of Object.values(schema)) {
@@ -160,7 +176,7 @@ function applyJsonRestCalendarDateWriteSerializers(scopeOptions = {}) {
   }
 }
 
-function normalizeJsonRestCalendarDateEntry(entry = null, scopes = {}) {
+function normalizeJsonRestTemporalEntry(entry = null, scopes = {}) {
   if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
     return entry;
   }
@@ -170,15 +186,16 @@ function normalizeJsonRestCalendarDateEntry(entry = null, scopes = {}) {
   );
   const attributes = normalizeJsonRestObject(entry.attributes);
   for (const [fieldName, definition] of Object.entries(schema)) {
-    if (
-      normalizeJsonRestText(definition?.type).toLowerCase() !== "date" ||
-      !Object.hasOwn(attributes, fieldName) ||
-      attributes[fieldName] == null
-    ) {
+    if (!Object.hasOwn(attributes, fieldName) || attributes[fieldName] == null) {
       continue;
     }
 
-    const canonical = resolveCanonicalCalendarDate(attributes[fieldName]);
+    const fieldType = normalizeJsonRestText(definition?.type).toLowerCase();
+    const canonical = fieldType === "date"
+      ? resolveCanonicalCalendarDate(attributes[fieldName])
+      : fieldType === "datetime"
+        ? resolveCanonicalDateTime(attributes[fieldName])
+        : "";
     if (canonical) {
       attributes[fieldName] = canonical;
     }
@@ -187,31 +204,31 @@ function normalizeJsonRestCalendarDateEntry(entry = null, scopes = {}) {
   return entry;
 }
 
-function normalizeJsonRestCalendarDateDocument(document = null, scopes = {}) {
+function normalizeJsonRestTemporalDocument(document = null, scopes = {}) {
   if (!document || typeof document !== "object" || Array.isArray(document)) {
     return document;
   }
 
   const data = Array.isArray(document.data) ? document.data : [document.data];
   for (const entry of data) {
-    normalizeJsonRestCalendarDateEntry(entry, scopes);
+    normalizeJsonRestTemporalEntry(entry, scopes);
   }
   for (const entry of Array.isArray(document.included) ? document.included : []) {
-    normalizeJsonRestCalendarDateEntry(entry, scopes);
+    normalizeJsonRestTemporalEntry(entry, scopes);
   }
   return document;
 }
 
-const JsonRestCalendarDatePlugin = Object.freeze({
-  name: "jskit-calendar-date",
+const JsonRestTemporalPlugin = Object.freeze({
+  name: "jskit-temporal",
   dependencies: ["rest-api"],
   install({ addHook, scopes }) {
     addHook("finish", "normalizeCalendarDateDocuments", {}, ({ context }) => {
       if (context?.record) {
-        normalizeJsonRestCalendarDateDocument(context.record, scopes);
+        normalizeJsonRestTemporalDocument(context.record, scopes);
       }
       if (context?.responseRecord) {
-        normalizeJsonRestCalendarDateDocument(context.responseRecord, scopes);
+        normalizeJsonRestTemporalDocument(context.responseRecord, scopes);
       }
     });
   }
@@ -815,7 +832,7 @@ async function createJsonRestApiHost({ knex }) {
     },
     presets: JSON_REST_AUTOFILTER_PRESETS
   });
-  await api.use(JsonRestCalendarDatePlugin);
+  await api.use(JsonRestTemporalPlugin);
 
   return api;
 }

package/test/entrypoints.boundary.test.js

@@ -641,7 +641,7 @@ test("createJsonRestApiHost installs json-rest-api query projections", async ()
   assert.equal(typeof api.resources.projectionContacts.vars.queryFields.displayName.select, "function");
 });
 
-test("createJsonRestApiHost returns calendar dates as YYYY-MM-DD without changing date-time or time fields", async () => {
+test("createJsonRestApiHost returns JSON-native temporal values from database records", async () => {
   const fakeKnex = Object.assign(() => {}, {
     client: {
       config: {
@@ -697,7 +697,7 @@ test("createJsonRestApiHost returns calendar dates as YYYY-MM-DD without changin
   });
 
   assert.equal(record.data.attributes.publishedOn, "2024-02-29");
-  assert.equal(record.data.attributes.scheduledAt, scheduledAt);
+  assert.equal(record.data.attributes.scheduledAt, "2024-02-29T12:34:56.000Z");
   assert.equal(record.data.attributes.opensAt, "09:45:00");
   assert.equal(record.included[0].attributes.observedOn, "2024-03-01");
 });
@@ -769,6 +769,38 @@ test("calendar date writes and responses keep leap day across server time zones"
   }
 });
 
+test("createJsonRestApiHost maps UTC database datetimes to RFC 3339 strings", async () => {
+  const fakeKnex = Object.assign(() => {}, {
+    client: { config: { client: "sqlite3" } },
+    async raw() {
+      return [{ version: "3.35.5" }];
+    },
+    transaction() {}
+  });
+  const api = await createJsonRestApiHost({ knex: fakeKnex });
+
+  await api.addResource("jobs", createJsonRestResourceScopeOptions({
+    tableName: "jobs",
+    schema: {
+      id: { type: "id", primary: true },
+      scheduledAt: { type: "dateTime" }
+    }
+  }));
+  const record = {
+    data: {
+      type: "jobs",
+      id: "1",
+      attributes: {
+        scheduledAt: "2024-02-29 12:34:56.123"
+      }
+    }
+  };
+
+  await api.runHooks("finish", { record });
+
+  assert.equal(record.data.attributes.scheduledAt, "2024-02-29T12:34:56.123Z");
+});
+
 test("returnNullWhenJsonRestResourceMissing only swallows missing-resource errors", async () => {
   await assert.doesNotReject(async () => {
     const result = await returnNullWhenJsonRestResourceMissing(async () => {