@jskit-ai/json-rest-api-core 0.1.104-oldline.0 → 0.1.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/json-rest-api-core",
-  "version": "0.1.104-oldline.0",
+  "version": "0.1.104",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -9,8 +9,45 @@
     "./server/jsonRestApiHost": "./src/server/jsonRestApiHost.js"
   },
   "dependencies": {
+    "@jskit-ai/database-runtime": "0.1.160",
+    "@jskit-ai/kernel": "0.1.160",
+    "@jskit-ai/resource-crud-core": "0.1.102",
     "hooked-api": "1.x.x",
-    "json-rest-api": "^1.0.27",
-    "@jskit-ai/kernel": "0.1.147"
+    "json-rest-api": "^1.0.27"
+  },
+  "description": "Shared internal json-rest-api host runtime with autofilter, query-projection, and row-policy support.",
+  "jskit": {
+    "kind": "runtime",
+    "capabilities": {
+      "provides": [
+        "runtime.json-rest-api"
+      ],
+      "requires": [
+        "runtime.database"
+      ]
+    },
+    "runtime": {
+      "server": {
+        "providers": [
+          {
+            "entrypoint": "src/server/JsonRestApiProvider.js",
+            "export": "JsonRestApiProvider"
+          }
+        ]
+      },
+      "client": {
+        "providers": []
+      }
+    },
+    "metadata": {
+      "apiSummary": {
+        "surfaces": [
+          {
+            "subpath": "./server",
+            "summary": "Provides runtime.json-rest-api and exports focused resource/query helpers, including server-only row policies."
+          }
+        ]
+      }
+    }
   }
 }

package/src/server/JsonRestApiProvider.js

@@ -0,0 +1,19 @@
+import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { createJsonRestApiHost } from "./jsonRestApiHost.js";
+
+const JsonRestApiProvider = defineProvider({
+  id: "runtime.json-rest-api",
+  requires: {
+    database: "runtime.database"
+  },
+  provides: {
+    jsonRestApi: "runtime.json-rest-api"
+  },
+  async setup({ database }) {
+    return {
+      jsonRestApi: await createJsonRestApiHost({ knex: database.knex })
+    };
+  }
+});
+
+export { JsonRestApiProvider };

package/src/server/jsonRestApiHost.js

@@ -11,15 +11,13 @@ import {
   normalizeRecordId,
   normalizeUniqueTextList
 } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveCrudResourceScopeName } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { resolveCrudResourceScopeName } from "@jskit-ai/resource-crud-core/shared/crudLookup";
 import {
   normalizeJsonApiFieldList,
   normalizeJsonApiFieldsets
 } from "@jskit-ai/kernel/shared/support/jsonApiFieldsets";
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 
-const INTERNAL_JSON_REST_API = "internal.json-rest-api";
-
 const JSON_REST_AUTOFILTER_PRESETS = Object.freeze({
   public: Object.freeze([]),
   workspace: Object.freeze([
@@ -108,38 +106,6 @@ function cloneJsonRestResourceValue(value, { writeSerializers = {} } = {}) {
   return next;
 }
 
-function applyJsonRestStorageColumns(scopeOptions = {}) {
-  const schema = normalizeJsonRestObject(scopeOptions.schema);
-  for (const [fieldName, fieldDefinition] of Object.entries(schema)) {
-    if (!isPlainJsonRestObject(fieldDefinition)) {
-      continue;
-    }
-
-    const actualField = normalizeJsonRestText(fieldDefinition.actualField);
-    if (!actualField) {
-      continue;
-    }
-
-    const storage = normalizeJsonRestObject(fieldDefinition.storage);
-    const storageColumn = normalizeJsonRestText(storage.column);
-    if (storage.virtual === true) {
-      throw new Error(
-        `json-rest-api schema field "${fieldName}" cannot define actualField when storage.virtual is true.`
-      );
-    }
-    if (storageColumn && storageColumn !== actualField) {
-      throw new Error(
-        `json-rest-api schema field "${fieldName}" actualField and storage.column must match.`
-      );
-    }
-
-    fieldDefinition.storage = {
-      ...storage,
-      column: actualField
-    };
-  }
-}
-
 function resolveCanonicalCalendarDate(value) {
   if (value instanceof Date) {
     return Number.isNaN(value.getTime())
@@ -709,7 +675,6 @@ function createJsonRestResourceScopeOptions(
   const scopeOptions = cloneJsonRestResourceValue(resource, {
     writeSerializers: normalizeJsonRestObject(writeSerializers)
   });
-  applyJsonRestStorageColumns(scopeOptions);
   applyJsonRestCalendarDateWriteSerializers(scopeOptions);
   if (isPlainJsonRestObject(searchSchema)) {
     scopeOptions.searchSchema = {
@@ -870,23 +835,7 @@ async function createJsonRestApiHost({ knex }) {
   return api;
 }
 
-async function registerJsonRestApiHost(app) {
-  if (!app || typeof app.instance !== "function" || typeof app.make !== "function" || typeof app.has !== "function") {
-    throw new Error("registerJsonRestApiHost requires application instance()/make()/has().");
-  }
-
-  if (app.has(INTERNAL_JSON_REST_API)) {
-    return app.make(INTERNAL_JSON_REST_API);
-  }
-
-  const knex = app.make("jskit.database.knex");
-  const api = await createJsonRestApiHost({ knex });
-  app.instance(INTERNAL_JSON_REST_API, api);
-  return api;
-}
-
 export {
-  INTERNAL_JSON_REST_API,
   JSON_REST_AUTOFILTER_PRESETS,
   addResourceIfMissing,
   buildJsonRestQueryParams,
@@ -900,6 +849,5 @@ export {
   returnBadRequestWhenJsonRestFieldsetInvalid,
   resolveWorkspaceScopeValue,
   resolveUserScopeValue,
-  createJsonRestApiHost,
-  registerJsonRestApiHost
+  createJsonRestApiHost
 };

package/test/entrypoints.boundary.test.js

@@ -6,7 +6,6 @@ import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { RestApiFieldsetError } from "json-rest-api";
 
 import {
-  INTERNAL_JSON_REST_API,
   addResourceIfMissing,
   buildJsonRestQueryParams,
   createJsonApiInputRecord,
@@ -16,13 +15,12 @@ import {
   createJsonRestApiHost,
   extractJsonRestCollectionRows,
   isJsonRestResourceMissingError,
-  registerJsonRestApiHost,
   returnNullWhenJsonRestResourceMissing,
   returnBadRequestWhenJsonRestFieldsetInvalid,
   resolveWorkspaceScopeValue,
   resolveUserScopeValue
 } from "../src/server/jsonRestApiHost.js";
-import { JsonRestApiCoreServiceProvider } from "../src/server/JsonRestApiCoreServiceProvider.js";
+import { JsonRestApiProvider } from "../src/server/JsonRestApiProvider.js";
 
 test("package exports include explicit server jsonRestApiHost entrypoint only", async () => {
   const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
@@ -32,13 +30,12 @@ test("package exports include explicit server jsonRestApiHost entrypoint only",
   assert.equal(packageJson.dependencies?.["json-rest-api"], "^1.0.27");
 });
 
-test("server jsonRestApiHost entrypoint no longer exports host-side JSON:API simplification helpers", async () => {
+test("server jsonRestApiHost entrypoint exposes only the focused host API", async () => {
   const hostModule = await import("../src/server/jsonRestApiHost.js");
   assert.equal(Object.hasOwn(hostModule, "simplifyJsonApiDocument"), false);
 });
 
 test("server entrypoint exports shared host helpers", () => {
-  assert.equal(INTERNAL_JSON_REST_API, "internal.json-rest-api");
   assert.equal(typeof addResourceIfMissing, "function");
   assert.equal(typeof buildJsonRestQueryParams, "function");
   assert.equal(typeof createJsonApiInputRecord, "function");
@@ -48,12 +45,13 @@ test("server entrypoint exports shared host helpers", () => {
   assert.equal(typeof createJsonRestApiHost, "function");
   assert.equal(typeof extractJsonRestCollectionRows, "function");
   assert.equal(typeof isJsonRestResourceMissingError, "function");
-  assert.equal(typeof registerJsonRestApiHost, "function");
   assert.equal(typeof returnNullWhenJsonRestResourceMissing, "function");
   assert.equal(typeof returnBadRequestWhenJsonRestFieldsetInvalid, "function");
   assert.equal(typeof resolveWorkspaceScopeValue, "function");
   assert.equal(typeof resolveUserScopeValue, "function");
-  assert.equal(typeof JsonRestApiCoreServiceProvider, "function");
+  assert.equal(JsonRestApiProvider.id, "runtime.json-rest-api");
+  assert.deepEqual(JsonRestApiProvider.requires, { database: "runtime.database" });
+  assert.deepEqual(JsonRestApiProvider.provides, { jsonRestApi: "runtime.json-rest-api" });
 });
 
 test("createJsonRestContext returns a mutable clone for frozen JSKIT execution context", () => {
@@ -460,48 +458,6 @@ test("createJsonRestResourceScopeOptions clones canonical resource metadata and
   assert.equal(source.schema.createdAt.indexed, undefined);
 });
 
-test("createJsonRestResourceScopeOptions maps resource actualField values to storage columns", () => {
-  const resource = Object.freeze({
-    namespace: "products",
-    schema: Object.freeze({
-      price1: Object.freeze({ type: "number", actualField: "price_1" }),
-      price2: Object.freeze({
-        type: "number",
-        actualField: "price_2",
-        storage: Object.freeze({ writeSerializer: "decimal" })
-      })
-    }),
-    searchSchema: Object.freeze({
-      minimumPrice: Object.freeze({ type: "number", actualField: "price_1", filterOperator: ">=" })
-    })
-  });
-  const decimalSerializer = (value) => value;
-
-  const result = createJsonRestResourceScopeOptions(resource, {
-    writeSerializers: { decimal: decimalSerializer }
-  });
-
-  assert.equal(result.schema.price1.storage.column, "price_1");
-  assert.equal(result.schema.price2.storage.column, "price_2");
-  assert.equal(result.schema.price2.storage.serialize, decimalSerializer);
-  assert.equal(result.searchSchema.minimumPrice.actualField, "price_1");
-  assert.equal(result.searchSchema.minimumPrice.storage, undefined);
-  assert.equal(resource.schema.price1.storage, undefined);
-
-  assert.throws(
-    () => createJsonRestResourceScopeOptions({
-      schema: {
-        price1: {
-          type: "number",
-          actualField: "price_1",
-          storage: { column: "price1" }
-        }
-      }
-    }),
-    /actualField and storage\.column must match/
-  );
-});
-
 test("createJsonRestResourceScopeOptions maps server query projections into json-rest-api queryFields", () => {
   const select = ({ knex }) => knex.raw("1");
   const resource = {

package/package.descriptor.mjs

@@ -1,60 +0,0 @@
-export default Object.freeze({
-  packageVersion: 1,
-  packageId: "@jskit-ai/json-rest-api-core",
-  version: "0.1.92",
-  kind: "runtime",
-  description: "Shared internal json-rest-api host runtime with autofilter, query-projection, and row-policy support.",
-  dependsOn: [
-    "@jskit-ai/database-runtime",
-    "@jskit-ai/kernel"
-  ],
-  capabilities: {
-    provides: [
-      "json-rest-api.core"
-    ],
-    requires: [
-      "runtime.database"
-    ]
-  },
-  runtime: {
-    server: {
-      providers: [
-        {
-          entrypoint: "src/server/JsonRestApiCoreServiceProvider.js",
-          export: "JsonRestApiCoreServiceProvider"
-        }
-      ]
-    },
-    client: {
-      providers: []
-    }
-  },
-  metadata: {
-    apiSummary: {
-      surfaces: [
-        {
-          subpath: "./server",
-          summary: "Exports the shared internal json-rest-api host token and resource registration helpers, including server-only row policies."
-        }
-      ],
-      containerTokens: {
-        server: [
-          "internal.json-rest-api"
-        ],
-        client: []
-      }
-    }
-  },
-  mutations: {
-    dependencies: {
-      runtime: {},
-      dev: {}
-    },
-    packageJson: {
-      scripts: {}
-    },
-    procfile: {},
-    files: [],
-    text: []
-  }
-});

package/src/server/JsonRestApiCoreServiceProvider.js

@@ -1,13 +0,0 @@
-import { registerJsonRestApiHost } from "./jsonRestApiHost.js";
-
-class JsonRestApiCoreServiceProvider {
-  static id = "json-rest-api.core";
-
-  static dependsOn = ["runtime.database"];
-
-  async boot(app) {
-    await registerJsonRestApiHost(app);
-  }
-}
-
-export { JsonRestApiCoreServiceProvider };