@jskit-ai/json-rest-api-core 0.1.1

package/package.descriptor.mjs

@@ -0,0 +1,60 @@
+export default Object.freeze({
+  packageVersion: 1,
+  packageId: "@jskit-ai/json-rest-api-core",
+  version: "0.1.1",
+  kind: "runtime",
+  description: "Shared internal json-rest-api host runtime for JSKIT server packages.",
+  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 host registration helpers."
+        }
+      ],
+      containerTokens: {
+        server: [
+          "internal.json-rest-api"
+        ],
+        client: []
+      }
+    }
+  },
+  mutations: {
+    dependencies: {
+      runtime: {},
+      dev: {}
+    },
+    packageJson: {
+      scripts: {}
+    },
+    procfile: {},
+    files: [],
+    text: []
+  }
+});

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@jskit-ai/json-rest-api-core",
+  "version": "0.1.1",
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  },
+  "exports": {
+    "./server/jsonRestApiHost": "./src/server/jsonRestApiHost.js"
+  },
+  "dependencies": {
+    "hooked-api": "1.x.x",
+    "json-rest-api": "1.x.x",
+    "@jskit-ai/kernel": "0.1.56"
+  }
+}

package/src/server/JsonRestApiCoreServiceProvider.js

@@ -0,0 +1,13 @@
+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 };

package/src/server/jsonRestApiHost.js

@@ -0,0 +1,491 @@
+import { Api } from "hooked-api";
+import { AutoFilterPlugin, RestApiKnexPlugin, RestApiPlugin } from "json-rest-api";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+
+const INTERNAL_JSON_REST_API = "internal.json-rest-api";
+
+const JSON_REST_AUTOFILTER_PRESETS = Object.freeze({
+  public: Object.freeze([]),
+  workspace: Object.freeze([
+    Object.freeze({
+      field: "workspaceId",
+      resolver: "workspace"
+    })
+  ]),
+  user: Object.freeze([
+    Object.freeze({
+      field: "userId",
+      resolver: "user"
+    })
+  ]),
+  workspace_user: Object.freeze([
+    Object.freeze({
+      field: "workspaceId",
+      resolver: "workspace"
+    }),
+    Object.freeze({
+      field: "userId",
+      resolver: "user"
+    })
+  ])
+});
+
+const JSON_REST_RESERVED_QUERY_KEYS = Object.freeze(new Set([
+  "cursor",
+  "limit",
+  "include",
+  "sort",
+  "fields"
+]));
+
+function isPlainJsonRestObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function cloneJsonRestResourceValue(value, { writeSerializers = {} } = {}) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneJsonRestResourceValue(entry, { writeSerializers }));
+  }
+
+  if (!isPlainJsonRestObject(value)) {
+    return value;
+  }
+
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    next[key] = cloneJsonRestResourceValue(entry, { writeSerializers });
+  }
+
+  if (isPlainJsonRestObject(next.storage)) {
+    const serializerKey = normalizeJsonRestText(next.storage.writeSerializer).toLowerCase();
+    if (serializerKey) {
+      const serializer = writeSerializers[serializerKey];
+      if (typeof serializer !== "function") {
+        throw new Error(`Unsupported json-rest-api write serializer: ${JSON.stringify(serializerKey)}.`);
+      }
+
+      next.storage = {
+        ...next.storage,
+        serialize: serializer
+      };
+      delete next.storage.writeSerializer;
+    }
+  }
+
+  return next;
+}
+
+async function addResourceIfMissing(api, scopeName, resourceConfig) {
+  if (api?.resources?.[scopeName]) {
+    return api.resources[scopeName];
+  }
+
+  await api.addResource(scopeName, resourceConfig);
+  return api.resources[scopeName];
+}
+
+function normalizeScopeValue(value) {
+  if (value == null) {
+    return null;
+  }
+
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    return normalized || null;
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : null;
+  }
+
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+
+  return null;
+}
+
+function normalizeJsonRestText(value, { fallback = "" } = {}) {
+  const normalized = String(value || "").trim();
+  return normalized || fallback;
+}
+
+function normalizeJsonRestObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+
+  return value;
+}
+
+function normalizeJsonRestList(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => normalizeJsonRestText(entry))
+      .filter(Boolean);
+  }
+
+  const normalized = normalizeJsonRestText(value);
+  if (!normalized) {
+    return [];
+  }
+
+  return normalized
+    .split(",")
+    .map((entry) => normalizeJsonRestText(entry))
+    .filter(Boolean);
+}
+
+function buildJsonRestQueryParams(resourceType = "", query = {}, { include = undefined } = {}) {
+  const normalizedResourceType = normalizeJsonRestText(resourceType);
+  const source = normalizeJsonRestObject(query);
+  const filters = {};
+
+  for (const [rawKey, rawValue] of Object.entries(source)) {
+    const key = normalizeJsonRestText(rawKey);
+    if (!key || JSON_REST_RESERVED_QUERY_KEYS.has(key)) {
+      continue;
+    }
+
+    const normalizedValue = normalizeJsonRestText(rawValue);
+    if (!normalizedValue) {
+      continue;
+    }
+
+    filters[key] = normalizedValue;
+  }
+
+  const queryParams = {};
+
+  if (Object.keys(filters).length > 0) {
+    queryParams.filters = filters;
+  }
+
+  const includeValues = normalizeJsonRestList(include === undefined ? source.include : include);
+  if (includeValues.length > 0) {
+    queryParams.include = includeValues;
+  }
+
+  const sortValues = normalizeJsonRestList(source.sort);
+  if (sortValues.length > 0) {
+    queryParams.sort = sortValues;
+  }
+
+  const cursor = normalizeJsonRestText(source.cursor);
+  const limitText = normalizeJsonRestText(source.limit);
+  if (cursor || limitText) {
+    queryParams.page = {
+      ...(cursor ? { after: cursor } : {}),
+      ...(limitText ? { size: limitText } : {})
+    };
+  }
+
+  const fields = normalizeJsonRestText(source.fields);
+  if (normalizedResourceType && fields) {
+    queryParams.fields = {
+      [normalizedResourceType]: fields
+    };
+  }
+
+  return queryParams;
+}
+
+function createJsonApiInputRecord(resourceType = "", attributes = {}, { id = null, relationships = null } = {}) {
+  const normalizedRelationships = normalizeJsonRestObject(relationships);
+  return {
+    data: {
+      type: normalizeJsonRestText(resourceType),
+      ...(id == null ? {} : { id: String(id) }),
+      attributes: {
+        ...normalizeJsonRestObject(attributes)
+      },
+      ...(Object.keys(normalizedRelationships).length < 1 ? {} : { relationships: normalizedRelationships })
+    }
+  };
+}
+
+function createJsonApiRelationship(resourceType = "", id = null) {
+  if (id == null) {
+    return {
+      data: null
+    };
+  }
+
+  return {
+    data: {
+      type: normalizeJsonRestText(resourceType),
+      id: String(id)
+    }
+  };
+}
+
+function createJsonRestResourceScopeOptions(resource = {}, { writeSerializers = {}, normalizeId = null } = {}) {
+  const scopeOptions = cloneJsonRestResourceValue(resource, {
+    writeSerializers: normalizeJsonRestObject(writeSerializers)
+  });
+
+  if (typeof normalizeId === "function") {
+    scopeOptions.normalizeId = normalizeId;
+  }
+
+  return scopeOptions;
+}
+
+function normalizeJsonApiResourceObject(resource = {}) {
+  const normalizedResource = normalizeJsonRestObject(resource);
+  return {
+    type: normalizeJsonRestText(normalizedResource.type),
+    id: normalizedResource.id == null ? null : String(normalizedResource.id),
+    attributes: normalizeJsonRestObject(normalizedResource.attributes),
+    relationships: normalizeJsonRestObject(normalizedResource.relationships)
+  };
+}
+
+function buildJsonApiIncludedIndex(payload = {}) {
+  const included = Array.isArray(payload?.included) ? payload.included : [];
+  const index = new Map();
+
+  for (const entry of included) {
+    const normalizedEntry = normalizeJsonApiResourceObject(entry);
+    if (!normalizedEntry.type || !normalizedEntry.id) {
+      continue;
+    }
+
+    index.set(`${normalizedEntry.type}:${normalizedEntry.id}`, normalizedEntry);
+  }
+
+  return index;
+}
+
+function simplifyJsonApiRelationshipData(data, { includedIndex = null, seen = null } = {}) {
+  if (Array.isArray(data)) {
+    return data
+      .map((entry) => simplifyJsonApiRelationshipData(entry, { includedIndex, seen }))
+      .filter((entry) => entry != null);
+  }
+
+  if (data == null) {
+    return null;
+  }
+
+  const normalizedReference = normalizeJsonApiResourceObject(data);
+  if (!normalizedReference.id) {
+    return null;
+  }
+
+  const referenceKey =
+    normalizedReference.type && normalizedReference.id
+      ? `${normalizedReference.type}:${normalizedReference.id}`
+      : "";
+  const nextSeen = seen instanceof Set ? new Set(seen) : new Set();
+
+  if (referenceKey) {
+    if (nextSeen.has(referenceKey)) {
+      return {
+        id: normalizedReference.id,
+        ...(normalizedReference.type ? { type: normalizedReference.type } : {})
+      };
+    }
+    nextSeen.add(referenceKey);
+  }
+
+  if (referenceKey && includedIndex instanceof Map && includedIndex.has(referenceKey)) {
+    return simplifyJsonApiResourceObject(includedIndex.get(referenceKey), {
+      includedIndex,
+      seen: nextSeen
+    });
+  }
+
+  return {
+    id: normalizedReference.id,
+    ...(normalizedReference.type ? { type: normalizedReference.type } : {})
+  };
+}
+
+function simplifyJsonApiResourceObject(resource = {}, { includedIndex = null, seen = null } = {}) {
+  const normalizedResource = normalizeJsonApiResourceObject(resource);
+  const resourceKey =
+    normalizedResource.type && normalizedResource.id
+      ? `${normalizedResource.type}:${normalizedResource.id}`
+      : "";
+  const nextSeen = seen instanceof Set ? new Set(seen) : new Set();
+
+  if (resourceKey) {
+    nextSeen.add(resourceKey);
+  }
+
+  const simplified = {
+    ...(normalizedResource.id == null ? {} : { id: normalizedResource.id }),
+    ...normalizedResource.attributes
+  };
+
+  for (const [relationshipKey, relationshipValue] of Object.entries(normalizedResource.relationships)) {
+    if (!relationshipKey || !relationshipValue || !Object.hasOwn(relationshipValue, "data")) {
+      continue;
+    }
+
+    simplified[relationshipKey] = simplifyJsonApiRelationshipData(relationshipValue.data, {
+      includedIndex,
+      seen: nextSeen
+    });
+  }
+
+  return simplified;
+}
+
+function simplifyJsonApiDocument(payload = {}) {
+  const source = normalizeJsonRestObject(payload);
+  const includedIndex = buildJsonApiIncludedIndex(source);
+
+  if (Array.isArray(source.data)) {
+    return source.data.map((entry) => simplifyJsonApiResourceObject(entry, { includedIndex }));
+  }
+
+  if (source.data && typeof source.data === "object") {
+    return simplifyJsonApiResourceObject(source.data, { includedIndex });
+  }
+
+  if (Object.hasOwn(source, "data") && source.data == null) {
+    return null;
+  }
+
+  if (source.meta && typeof source.meta === "object" && !Array.isArray(source.meta)) {
+    return source.meta;
+  }
+
+  return payload;
+}
+
+function createJsonRestContext(context = null) {
+  if (!context || typeof context !== "object" || Array.isArray(context)) {
+    return {};
+  }
+
+  const nextContext = {
+    ...context
+  };
+
+  if (context.visibilityContext && typeof context.visibilityContext === "object" && !Array.isArray(context.visibilityContext)) {
+    nextContext.visibilityContext = {
+      ...context.visibilityContext
+    };
+  }
+
+  if (context.scopeValues && typeof context.scopeValues === "object" && !Array.isArray(context.scopeValues)) {
+    nextContext.scopeValues = {
+      ...context.scopeValues
+    };
+  }
+
+  return nextContext;
+}
+
+function resolveWorkspaceScopeValue(context = null) {
+  const explicitScopeValue = normalizeScopeValue(context?.scopeValues?.workspaceId);
+  if (explicitScopeValue) {
+    return explicitScopeValue;
+  }
+
+  return normalizeScopeValue(context?.visibilityContext?.scopeOwnerId);
+}
+
+function resolveUserScopeValue(context = null) {
+  const explicitScopeValue = normalizeScopeValue(context?.scopeValues?.userId);
+  if (explicitScopeValue) {
+    return explicitScopeValue;
+  }
+
+  return normalizeScopeValue(context?.visibilityContext?.userId);
+}
+
+function isJsonRestResourceMissingError(error = null) {
+  return normalizeJsonRestText(error?.code) === "REST_API_RESOURCE" &&
+    normalizeJsonRestText(error?.subtype) === "not_found";
+}
+
+async function returnNullWhenJsonRestResourceMissing(run) {
+  if (typeof run !== "function") {
+    throw new TypeError("returnNullWhenJsonRestResourceMissing requires run function.");
+  }
+
+  try {
+    return await run();
+  } catch (error) {
+    if (isJsonRestResourceMissingError(error)) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+async function createJsonRestApiHost({ knex }) {
+  if (typeof knex !== "function") {
+    throw new TypeError("createJsonRestApiHost requires knex.");
+  }
+
+  const api = new Api({
+    name: "jskit-internal-json-rest-api",
+    logLevel: "error"
+  });
+
+  await api.use(RestApiPlugin, {
+    simplifiedApi: true,
+    simplifiedTransport: false,
+    returnRecordApi: {
+      post: "full",
+      put: "full",
+      patch: "full"
+    },
+    normalizeId: normalizeRecordId
+  });
+
+  await api.use(RestApiKnexPlugin, { knex });
+  await api.use(AutoFilterPlugin, {
+    resolvers: {
+      workspace: ({ context }) => resolveWorkspaceScopeValue(context),
+      user: ({ context }) => resolveUserScopeValue(context)
+    },
+    presets: JSON_REST_AUTOFILTER_PRESETS
+  });
+
+  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,
+  createJsonApiInputRecord,
+  createJsonApiRelationship,
+  createJsonRestResourceScopeOptions,
+  createJsonRestContext,
+  isJsonRestResourceMissingError,
+  returnNullWhenJsonRestResourceMissing,
+  resolveWorkspaceScopeValue,
+  resolveUserScopeValue,
+  simplifyJsonApiDocument,
+  createJsonRestApiHost,
+  registerJsonRestApiHost
+};

package/test/entrypoints.boundary.test.js

@@ -0,0 +1,333 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+
+import {
+  INTERNAL_JSON_REST_API,
+  addResourceIfMissing,
+  buildJsonRestQueryParams,
+  createJsonApiInputRecord,
+  createJsonApiRelationship,
+  createJsonRestResourceScopeOptions,
+  createJsonRestContext,
+  createJsonRestApiHost,
+  isJsonRestResourceMissingError,
+  registerJsonRestApiHost,
+  returnNullWhenJsonRestResourceMissing,
+  resolveWorkspaceScopeValue,
+  resolveUserScopeValue,
+  simplifyJsonApiDocument
+} from "../src/server/jsonRestApiHost.js";
+import { JsonRestApiCoreServiceProvider } from "../src/server/JsonRestApiCoreServiceProvider.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"));
+  const exportsMap = packageJson && typeof packageJson === "object" ? packageJson.exports : {};
+  assert.equal(exportsMap["./server/jsonRestApiHost"], "./src/server/jsonRestApiHost.js");
+  assert.equal(exportsMap["./server"], undefined);
+});
+
+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");
+  assert.equal(typeof createJsonApiRelationship, "function");
+  assert.equal(typeof createJsonRestResourceScopeOptions, "function");
+  assert.equal(typeof createJsonRestContext, "function");
+  assert.equal(typeof createJsonRestApiHost, "function");
+  assert.equal(typeof isJsonRestResourceMissingError, "function");
+  assert.equal(typeof registerJsonRestApiHost, "function");
+  assert.equal(typeof returnNullWhenJsonRestResourceMissing, "function");
+  assert.equal(typeof resolveWorkspaceScopeValue, "function");
+  assert.equal(typeof resolveUserScopeValue, "function");
+  assert.equal(typeof simplifyJsonApiDocument, "function");
+  assert.equal(typeof JsonRestApiCoreServiceProvider, "function");
+});
+
+test("createJsonRestContext returns a mutable clone for frozen JSKIT execution context", () => {
+  const source = Object.freeze({
+    visibilityContext: Object.freeze({
+      visibility: "workspace",
+      scopeOwnerId: "workspace-7",
+      userId: "user-2"
+    }),
+    scopeValues: Object.freeze({
+      workspaceId: "workspace-explicit"
+    }),
+    requestMeta: Object.freeze({
+      traceId: "trace-1"
+    })
+  });
+
+  const result = createJsonRestContext(source);
+
+  assert.notEqual(result, source);
+  assert.notEqual(result.visibilityContext, source.visibilityContext);
+  assert.notEqual(result.scopeValues, source.scopeValues);
+  assert.equal(result.requestMeta, source.requestMeta);
+
+  result.method = "query";
+  result.scopeValues.userId = "user-2";
+
+  assert.equal(result.method, "query");
+  assert.equal(result.scopeValues.userId, "user-2");
+  assert.equal(source.scopeValues.userId, undefined);
+});
+
+test("createJsonRestContext returns an empty mutable object when source context is absent", () => {
+  const result = createJsonRestContext(null);
+
+  assert.deepEqual(result, {});
+  result.method = "query";
+  assert.equal(result.method, "query");
+});
+
+test("createJsonRestApiHost installs normalizeRecordId as the default resource id normalizer", async () => {
+  const fakeKnex = Object.assign(() => {}, {
+    client: {
+      config: {
+        client: "sqlite3"
+      }
+    },
+    async raw() {
+      return [
+        {
+          version: "3.35.5"
+        }
+      ];
+    },
+    transaction() {}
+  });
+
+  const api = await createJsonRestApiHost({
+    knex: fakeKnex
+  });
+
+  assert.equal(api.vars.normalizeId, normalizeRecordId);
+});
+
+test("shared query/document helpers build json-rest-api request shapes", () => {
+  assert.deepEqual(
+    buildJsonRestQueryParams("contacts", {
+      q: "Merc",
+      cursor: "cursor_2",
+      limit: 10,
+      include: "workspace,user",
+      sort: ["-createdAt", "name"],
+      fields: "name,dob"
+    }),
+    {
+      filters: {
+        q: "Merc"
+      },
+      include: ["workspace", "user"],
+      sort: ["-createdAt", "name"],
+      page: {
+        after: "cursor_2",
+        size: "10"
+      },
+      fields: {
+        contacts: "name,dob"
+      }
+    }
+  );
+
+  assert.deepEqual(
+    createJsonApiInputRecord("contacts", {
+      name: "Merc"
+    }, {
+      id: 7,
+      relationships: {
+        workspace: createJsonApiRelationship("workspaces", 9)
+      }
+    }),
+    {
+      data: {
+        type: "contacts",
+        id: "7",
+        attributes: {
+          name: "Merc"
+        },
+        relationships: {
+          workspace: {
+            data: {
+              type: "workspaces",
+              id: "9"
+            }
+          }
+        }
+      }
+    }
+  );
+
+  assert.deepEqual(
+    simplifyJsonApiDocument({
+      data: [
+        {
+          type: "workspace-memberships",
+          id: "11",
+          attributes: {
+            roleSid: "owner"
+          },
+          relationships: {
+            user: {
+              data: {
+                type: "user-profiles",
+                id: "9"
+              }
+            }
+          }
+        }
+      ],
+      included: [
+        {
+          type: "user-profiles",
+          id: "9",
+          attributes: {
+            displayName: "Chiara"
+          }
+        }
+      ]
+    }),
+    [
+      {
+        id: "11",
+        roleSid: "owner",
+        user: {
+          id: "9",
+          displayName: "Chiara"
+        }
+      }
+    ]
+  );
+});
+
+test("createJsonRestResourceScopeOptions clones canonical resource metadata and resolves symbolic write serializers", () => {
+  const serializer = (value) => value;
+  const normalizeId = (value) => String(value || "").trim() || null;
+  const source = Object.freeze({
+    namespace: "contacts",
+    tableName: "contacts",
+    defaultSort: Object.freeze(["-createdAt"]),
+    schema: Object.freeze({
+      name: Object.freeze({
+        type: "string",
+        maxLength: 190,
+        required: true,
+        search: true,
+        operations: Object.freeze({
+          output: Object.freeze({
+            required: true
+          })
+        })
+      }),
+      createdAt: Object.freeze({
+        type: "dateTime",
+        storage: Object.freeze({
+          column: "created_at",
+          writeSerializer: "datetime-utc"
+        }),
+        operations: Object.freeze({
+          output: Object.freeze({
+            required: true
+          })
+        })
+      })
+    }),
+    operations: Object.freeze({
+      view: Object.freeze({
+        method: "GET"
+      })
+    })
+  });
+
+  const result = createJsonRestResourceScopeOptions(source, {
+    normalizeId,
+    writeSerializers: {
+      "datetime-utc": serializer
+    }
+  });
+
+  assert.notEqual(result, source);
+  assert.notEqual(result.schema, source.schema);
+  assert.notEqual(result.schema.createdAt, source.schema.createdAt);
+  assert.equal(result.schema.createdAt.storage.column, "created_at");
+  assert.equal(result.schema.createdAt.storage.serialize, serializer);
+  assert.equal(result.schema.createdAt.storage.writeSerializer, undefined);
+  assert.equal(result.normalizeId, normalizeId);
+  assert.equal(result.schema.name.maxLength, 190);
+  assert.equal(result.schema.name.operations.output.required, true);
+  assert.equal(result.operations.view.method, "GET");
+
+  result.schema.createdAt.indexed = true;
+  assert.equal(source.schema.createdAt.indexed, undefined);
+});
+
+test("returnNullWhenJsonRestResourceMissing only swallows missing-resource errors", async () => {
+  await assert.doesNotReject(async () => {
+    const result = await returnNullWhenJsonRestResourceMissing(async () => {
+      return "ok";
+    });
+
+    assert.equal(result, "ok");
+  });
+
+  const missing = Object.freeze({
+    code: "REST_API_RESOURCE",
+    subtype: "not_found"
+  });
+
+  assert.equal(isJsonRestResourceMissingError(missing), true);
+  assert.equal(await returnNullWhenJsonRestResourceMissing(async () => {
+    throw missing;
+  }), null);
+
+  const otherError = new Error("boom");
+  await assert.rejects(
+    async () => returnNullWhenJsonRestResourceMissing(async () => {
+      throw otherError;
+    }),
+    (error) => error === otherError
+  );
+});
+
+test("scope resolvers understand explicit scopeValues and JSKIT visibilityContext", () => {
+  assert.equal(resolveWorkspaceScopeValue({
+    scopeValues: {
+      workspaceId: "workspace-explicit"
+    },
+    visibilityContext: {
+      scopeOwnerId: "workspace-visibility"
+    }
+  }), "workspace-explicit");
+
+  assert.equal(resolveWorkspaceScopeValue({
+    visibilityContext: {
+      scopeOwnerId: 42
+    }
+  }), "42");
+
+  assert.equal(resolveUserScopeValue({
+    scopeValues: {
+      userId: "user-explicit"
+    },
+    visibilityContext: {
+      userId: "user-visibility"
+    }
+  }), "user-explicit");
+
+  assert.equal(resolveUserScopeValue({
+    visibilityContext: {
+      userId: 7
+    }
+  }), "7");
+
+  assert.equal(resolveWorkspaceScopeValue({
+    visibilityContext: {
+      scopeOwnerId: "   "
+    }
+  }), null);
+  assert.equal(resolveUserScopeValue(null), null);
+});