@jskit-ai/crud-core 0.1.63 → 0.1.64

package/src/server/resourceRuntime/index.js

@@ -6,7 +6,6 @@ import {
 import { applyVisibility, applyVisibilityOwners } from "@jskit-ai/database-runtime/shared/visibility";
 import { AppError, createValidationError } from "@jskit-ai/kernel/server/runtime/errors";
 import { isRecord, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { Check, Errors } from "typebox/value";
 import {
   DEFAULT_LIST_LIMIT,
   MAX_LIST_LIMIT,
@@ -20,11 +19,15 @@ import {
   resolveColumnName,
   resolveCrudIdColumn
 } from "../repositorySupport.js";
+import {
+  resolveStructuredSchemaTransportSchema,
+  validateSchemaPayload
+} from "@jskit-ai/kernel/shared/validators";
 import {
   createCrudLookupRuntime,
   hydrateCrudLookupRecords
 } from "./lookupHydration.js";
-import { CRUD_FIELD_REPOSITORY_STORAGE_COLUMN } from "../../shared/crudFieldMetaSupport.js";
+import { CRUD_FIELD_STORAGE_COLUMN } from "@jskit-ai/kernel/shared/support/crudFieldContract";
 
 const LIST_ORDER_DIRECTION_ASC = "asc";
 const LIST_ORDER_DIRECTION_DESC = "desc";
@@ -77,11 +80,11 @@ function resolveRepositoryDefaults(resource = {}, repositoryMapping = {}, { cont
 
   const idColumn = normalizeText(resource.idColumn) || resolveColumnName("id", repositoryMapping.columnOverrides) || "id";
   const createdAtColumn = repositoryMapping.outputKeys.includes("createdAt") &&
-    repositoryMapping.fieldStorageByKey?.createdAt === CRUD_FIELD_REPOSITORY_STORAGE_COLUMN
+    repositoryMapping.fieldStorageByKey?.createdAt === CRUD_FIELD_STORAGE_COLUMN
     ? resolveColumnName("createdAt", repositoryMapping.columnOverrides)
     : "";
   const updatedAtColumn = repositoryMapping.outputKeys.includes("updatedAt") &&
-    repositoryMapping.fieldStorageByKey?.updatedAt === CRUD_FIELD_REPOSITORY_STORAGE_COLUMN
+    repositoryMapping.fieldStorageByKey?.updatedAt === CRUD_FIELD_STORAGE_COLUMN
     ? resolveColumnName("updatedAt", repositoryMapping.columnOverrides)
     : "";
 
@@ -112,7 +115,7 @@ function normalizeCrudVirtualFieldHandlers(
     }
     if (Object.keys(virtualFields).length > 0) {
       throw new Error(
-        `${context} virtualFields contains registrations, but the resource does not declare any repository.storage "virtual" fields.`
+        `${context} virtualFields contains registrations, but the resource does not declare any storage.virtual fields.`
       );
     }
     return Object.freeze([]);
@@ -131,7 +134,7 @@ function normalizeCrudVirtualFieldHandlers(
     }
     if (!expectedKeys.has(key)) {
       throw new Error(
-        `${context} virtualFields["${key}"] is unknown; declare the field in resource.fieldMeta with repository.storage "virtual".`
+        `${context} virtualFields["${key}"] is unknown; declare the field in the resource schema with storage.virtual true.`
       );
     }
     if (!handlerConfig || typeof handlerConfig !== "object" || Array.isArray(handlerConfig)) {
@@ -289,48 +292,32 @@ function resolveListRuntimeConfig(list = {}, fallbackSearchColumns = [], { idCol
   });
 }
 
-function formatOutputValidationError(issue = {}) {
-  const path = Array.isArray(issue.path) ? issue.path.join(".") : "";
-  const value = issue.value;
-  const message = normalizeText(issue.message) || "Invalid value";
-  if (path) {
-    return `${path}: ${message}`;
-  }
-  if (value !== undefined) {
-    return `${message} (${JSON.stringify(value)})`;
-  }
-  return message;
-}
-
 function resolveRecordOutputValidator(resource = {}, { context = "crudRepository" } = {}) {
-  const outputValidator = resource?.operations?.view?.outputValidator;
-  if (!outputValidator || typeof outputValidator !== "object" || Array.isArray(outputValidator)) {
-    throw new TypeError(`${context} requires operations.view.outputValidator.`);
+  const output = resource?.operations?.view?.output;
+  if (!output || typeof output !== "object" || Array.isArray(output)) {
+    throw new TypeError(`${context} requires operations.view.output.`);
   }
-  if (!outputValidator.schema || typeof outputValidator.schema !== "object" || Array.isArray(outputValidator.schema)) {
-    throw new TypeError(`${context} requires operations.view.outputValidator.schema.`);
+  const schema = resolveStructuredSchemaTransportSchema(output, {
+    context: `${context} operations.view.output`,
+    defaultMode: "replace"
+  });
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    throw new TypeError(`${context} requires operations.view.output to resolve to an object schema.`);
   }
 
-  return Object.freeze({
-    schema: outputValidator.schema,
-    normalize: typeof outputValidator.normalize === "function" ? outputValidator.normalize : null
-  });
+  return output;
 }
 
 function resolveOperationBodyValidator(resource = {}, operationKey = "", { context = "crudRepository" } = {}) {
-  const bodyValidator = resource?.operations?.[operationKey]?.bodyValidator;
-  if (bodyValidator == null) {
-    return Object.freeze({
-      normalize: null
-    });
+  const body = resource?.operations?.[operationKey]?.body;
+  if (body == null) {
+    return null;
   }
-  if (!bodyValidator || typeof bodyValidator !== "object" || Array.isArray(bodyValidator)) {
-    throw new TypeError(`${context} operations.${operationKey}.bodyValidator must be an object when provided.`);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new TypeError(`${context} operations.${operationKey}.body must be an object when provided.`);
   }
 
-  return Object.freeze({
-    normalize: typeof bodyValidator.normalize === "function" ? bodyValidator.normalize : null
-  });
+  return body;
 }
 
 function extractExplicitFieldErrors(error) {
@@ -357,34 +344,21 @@ async function normalizeRepositoryInputPayload(
     actionContextBase = {}
   } = {}
 ) {
-  const inputValidator = operationKey === "patch"
+  const input = operationKey === "patch"
     ? runtime.input?.patch
     : runtime.input?.create;
   const normalizedPayload = normalizeCrudRepositoryObjectInput(payload);
 
-  if (typeof inputValidator?.normalize !== "function") {
+  if (!input) {
     return normalizedPayload;
   }
 
   try {
-    const nextPayload = await inputValidator.normalize(normalizedPayload, {
-      phase,
-      action,
-      recordId,
-      existingRecord,
-      context: actionContextBase?.callOptions?.context,
-      callOptions: actionContextBase?.callOptions,
-      repositoryOptions: actionContextBase?.repositoryOptions
+    const nextPayload = validateSchemaPayload(input, normalizedPayload, {
+      phase: "input",
+      context: `${runtime?.context || "crudRepository"} operations.${operationKey}.body`
     });
-    if (nextPayload === undefined) {
-      return normalizedPayload;
-    }
-    if (!nextPayload || typeof nextPayload !== "object" || Array.isArray(nextPayload)) {
-      throw new TypeError(
-        `${runtime?.context || "crudRepository"} operations.${operationKey}.bodyValidator.normalize must return an object when it returns a value.`
-      );
-    }
-    return nextPayload;
+    return normalizeCrudRepositoryObjectInput(nextPayload);
   } catch (error) {
     const explicitFieldErrors = extractExplicitFieldErrors(error);
     if (explicitFieldErrors) {
@@ -395,24 +369,25 @@ async function normalizeRepositoryInputPayload(
 }
 
 async function normalizeRepositoryOutputRecord(runtime = {}, record = {}, { operation = "list" } = {}) {
-  const outputRuntime = runtime.output;
-  let normalizedRecord = record;
-  if (typeof outputRuntime.normalize === "function") {
-    normalizedRecord = await outputRuntime.normalize(record, {
-      phase: "crudRepositoryOutput",
-      operation
+  try {
+    return validateSchemaPayload(runtime.output, record, {
+      phase: "output",
+      context: `${runtime?.context || "crudRepository"} operations.view.output`
     });
+  } catch (error) {
+    const explicitFieldErrors = extractExplicitFieldErrors(error);
+    if (explicitFieldErrors) {
+      const detailMessage = Object.entries(explicitFieldErrors)
+        .map(([field, message]) => `${field}: ${message}`)
+        .join(", ");
+      throw new TypeError(
+        `${runtime?.context || "crudRepository"} ${operation} output validation failed: ${detailMessage}.`
+      );
+    }
+    throw new TypeError(
+      `${runtime?.context || "crudRepository"} ${operation} output validation failed: ${String(error?.message || "Invalid value.")}.`
+    );
   }
-
-  if (Check(outputRuntime.schema, normalizedRecord)) {
-    return normalizedRecord;
-  }
-
-  const issues = [...Errors(outputRuntime.schema, normalizedRecord)];
-  const formattedIssue = formatOutputValidationError(issues[0]);
-  throw new TypeError(
-    `${runtime?.context || "crudRepository"} ${operation} output validation failed: ${formattedIssue}.`
-  );
 }
 
 function encodeOrderedListCursorValue(value = null) {
@@ -1070,7 +1045,7 @@ async function listRecordsByIds(runtime, knex, ids = [], callOptions = {}) {
       `${runtime.context || "crudRepository"} listByIds requires valueKey "${lookupValueKey}" to exist in output schema.`
     );
   }
-  if (runtime.mapping.fieldStorageByKey?.[lookupValueKey] !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+  if (runtime.mapping.fieldStorageByKey?.[lookupValueKey] !== CRUD_FIELD_STORAGE_COLUMN) {
     throw new TypeError(
       `${runtime.context || "crudRepository"} listByIds requires valueKey "${lookupValueKey}" to be column-backed.`
     );

package/src/server/resourceRuntime/lookupHydration.js

@@ -6,6 +6,7 @@ import {
   normalizeCrudLookupContainerKey,
   resolveCrudLookupContainerKey
 } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { buildCrudFieldContractMap } from "@jskit-ai/kernel/shared/support/crudFieldContract";
 import { normalizeCrudLookupApiPath } from "../lookupPathSupport.js";
 
 const DEFAULT_LOOKUP_INCLUDE = "*";
@@ -136,7 +137,9 @@ function createCrudLookupRuntime(resource = {}, { outputKeys = [] } = {}) {
       .filter(Boolean)
   );
 
-  const sourceEntries = Array.isArray(resource?.fieldMeta) ? resource.fieldMeta : [];
+  const sourceEntries = Object.values(buildCrudFieldContractMap(resource, {
+    context: "crud lookup runtime field contract"
+  }));
   const lookupEntries = [];
   const seenKeys = new Set();
 

package/src/server/routeContracts.js

@@ -0,0 +1,74 @@
+import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/shared/validators/jsonApiRouteTransport";
+import {
+  composeSchemaDefinitions,
+  recordIdParamsValidator
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  createCrudCursorPaginationQueryValidator,
+  listSearchQueryValidator as defaultListSearchQueryValidator,
+  lookupIncludeQueryValidator as defaultLookupIncludeQueryValidator,
+  createCrudParentFilterQueryValidator
+} from "./listQueryValidators.js";
+
+function createCrudJsonApiRouteContracts({
+  resource = {},
+  routeParamsValidator = null,
+  listSearchQueryValidator = defaultListSearchQueryValidator,
+  lookupIncludeQueryValidator = defaultLookupIncludeQueryValidator
+} = {}) {
+  const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator({
+    orderBy: resource?.defaultSort
+  });
+  const listParentFilterQueryValidator = createCrudParentFilterQueryValidator(resource);
+  const listRouteQueryValidator = composeSchemaDefinitions([
+    listCursorPaginationQueryValidator,
+    listSearchQueryValidator,
+    listParentFilterQueryValidator,
+    lookupIncludeQueryValidator
+  ]);
+  const recordRouteParamsValidator = routeParamsValidator
+    ? composeSchemaDefinitions([
+        routeParamsValidator,
+        recordIdParamsValidator
+      ])
+    : recordIdParamsValidator;
+  const routeType = resource?.namespace;
+
+  return Object.freeze({
+    listRouteContract: createJsonApiResourceRouteContract({
+      type: routeType,
+      query: listRouteQueryValidator,
+      output: resource?.operations?.view?.output,
+      outputKind: "collection"
+    }),
+    viewRouteContract: createJsonApiResourceRouteContract({
+      type: routeType,
+      query: lookupIncludeQueryValidator,
+      output: resource?.operations?.view?.output,
+      outputKind: "record"
+    }),
+    createRouteContract: createJsonApiResourceRouteContract({
+      type: routeType,
+      body: resource?.operations?.create?.body,
+      output: resource?.operations?.create?.output,
+      outputKind: "record",
+      successStatus: 201,
+      includeValidation400: true
+    }),
+    updateRouteContract: createJsonApiResourceRouteContract({
+      type: routeType,
+      body: resource?.operations?.patch?.body,
+      output: resource?.operations?.patch?.output,
+      outputKind: "record",
+      includeValidation400: true
+    }),
+    deleteRouteContract: createJsonApiResourceRouteContract({
+      type: routeType,
+      outputKind: "no-content",
+      successStatus: 204
+    }),
+    recordRouteParamsValidator
+  });
+}
+
+export { createCrudJsonApiRouteContracts };

package/src/server/serviceEvents.js

@@ -3,6 +3,22 @@ import {
   resolveCrudRecordChangedEvent
 } from "../shared/crudNamespaceSupport.js";
 
+function normalizeCrudEventEntityId(value = null) {
+  return value == null ? "" : String(value).trim();
+}
+
+function resolveCrudEntityIdFromResult({ result } = {}) {
+  return normalizeCrudEventEntityId(result?.id);
+}
+
+function resolveCrudJsonApiEntityIdFromResult({ result } = {}) {
+  return normalizeCrudEventEntityId(result?.data?.id);
+}
+
+function resolveCrudEntityIdFromArgs({ args = [] } = {}) {
+  return normalizeCrudEventEntityId(args[0]);
+}
+
 function createCrudServiceEvents(resource = {}, { context = "crudService" } = {}) {
   const namespace = requireCrudNamespace(resource?.namespace, { context: `${context} resource.namespace` });
   const recordChangedEventName = resolveCrudRecordChangedEvent(namespace);
@@ -14,7 +30,7 @@ function createCrudServiceEvents(resource = {}, { context = "crudService" } = {}
         source: "crud",
         entity: "record",
         operation: "created",
-        entityId: ({ result }) => result?.id,
+        entityId: resolveCrudEntityIdFromResult,
         realtime: Object.freeze({
           event: recordChangedEventName,
           audience: "event_scope"
@@ -27,7 +43,7 @@ function createCrudServiceEvents(resource = {}, { context = "crudService" } = {}
         source: "crud",
         entity: "record",
         operation: "updated",
-        entityId: ({ result }) => result?.id,
+        entityId: resolveCrudEntityIdFromResult,
         realtime: Object.freeze({
           event: recordChangedEventName,
           audience: "event_scope"
@@ -40,7 +56,56 @@ function createCrudServiceEvents(resource = {}, { context = "crudService" } = {}
         source: "crud",
         entity: "record",
         operation: "deleted",
-        entityId: ({ result }) => result?.id,
+        entityId: resolveCrudEntityIdFromResult,
+        realtime: Object.freeze({
+          event: recordChangedEventName,
+          audience: "event_scope"
+        })
+      })
+    ])
+  });
+}
+
+function createCrudJsonApiServiceEvents(namespace = "", { context = "createCrudJsonApiServiceEvents" } = {}) {
+  const normalizedNamespace = requireCrudNamespace(namespace, {
+    context: `${context} namespace`
+  });
+  const recordChangedEventName = resolveCrudRecordChangedEvent(normalizedNamespace);
+
+  return Object.freeze({
+    createDocument: Object.freeze([
+      Object.freeze({
+        type: "entity.changed",
+        source: "crud",
+        entity: "record",
+        operation: "created",
+        entityId: resolveCrudJsonApiEntityIdFromResult,
+        realtime: Object.freeze({
+          event: recordChangedEventName,
+          audience: "event_scope"
+        })
+      })
+    ]),
+    patchDocumentById: Object.freeze([
+      Object.freeze({
+        type: "entity.changed",
+        source: "crud",
+        entity: "record",
+        operation: "updated",
+        entityId: resolveCrudEntityIdFromArgs,
+        realtime: Object.freeze({
+          event: recordChangedEventName,
+          audience: "event_scope"
+        })
+      })
+    ]),
+    deleteDocumentById: Object.freeze([
+      Object.freeze({
+        type: "entity.changed",
+        source: "crud",
+        entity: "record",
+        operation: "deleted",
+        entityId: resolveCrudEntityIdFromArgs,
         realtime: Object.freeze({
           event: recordChangedEventName,
           audience: "event_scope"
@@ -50,4 +115,10 @@ function createCrudServiceEvents(resource = {}, { context = "crudService" } = {}
   });
 }
 
-export { createCrudServiceEvents };
+export {
+  createCrudServiceEvents,
+  createCrudJsonApiServiceEvents,
+  resolveCrudEntityIdFromArgs,
+  resolveCrudEntityIdFromResult,
+  resolveCrudJsonApiEntityIdFromResult
+};

package/src/shared/crudFieldSupport.js

@@ -0,0 +1,54 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  DEFAULT_CRUD_LOOKUP_CONTAINER_KEY,
+  normalizeCrudLookupContainerKey
+} from "@jskit-ai/kernel/shared/support/crudLookup";
+
+const CRUD_RUNTIME_LOOKUPS_FIELD_KEY = DEFAULT_CRUD_LOOKUP_CONTAINER_KEY;
+const CRUD_LOOKUP_FORM_CONTROL_AUTOCOMPLETE = "autocomplete";
+const CRUD_LOOKUP_FORM_CONTROL_SELECT = "select";
+
+function checkCrudLookupFormControl(
+  value,
+  {
+    context = "crud field ui.formControl",
+    defaultValue = CRUD_LOOKUP_FORM_CONTROL_AUTOCOMPLETE
+  } = {}
+) {
+  const resolvedValue = value === undefined || value === null || value === "" ? defaultValue : value;
+  if (resolvedValue === "") {
+    return "";
+  }
+
+  if (
+    resolvedValue === CRUD_LOOKUP_FORM_CONTROL_AUTOCOMPLETE ||
+    resolvedValue === CRUD_LOOKUP_FORM_CONTROL_SELECT
+  ) {
+    return resolvedValue;
+  }
+
+  throw new Error(
+    `${context} must be "${CRUD_LOOKUP_FORM_CONTROL_AUTOCOMPLETE}" or "${CRUD_LOOKUP_FORM_CONTROL_SELECT}". ` +
+      `Received: ${JSON.stringify(resolvedValue)}.`
+  );
+}
+
+function isCrudRuntimeOutputOnlyFieldKey(
+  value = "",
+  {
+    lookupContainerKey = CRUD_RUNTIME_LOOKUPS_FIELD_KEY
+  } = {}
+) {
+  const resolvedLookupContainerKey = normalizeCrudLookupContainerKey(lookupContainerKey, {
+    context: "crud runtime lookup container key"
+  });
+  return normalizeText(value) === resolvedLookupContainerKey;
+}
+
+export {
+  CRUD_LOOKUP_FORM_CONTROL_AUTOCOMPLETE,
+  CRUD_LOOKUP_FORM_CONTROL_SELECT,
+  CRUD_RUNTIME_LOOKUPS_FIELD_KEY,
+  checkCrudLookupFormControl,
+  isCrudRuntimeOutputOnlyFieldKey
+};

package/src/shared/crudNamespaceSupport.js

@@ -1,31 +1,5 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function normalizeCrudNamespace(value = "") {
-  return normalizeText(value)
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, "-")
-    .replace(/-+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-function requireCrudNamespace(namespace, { context = "requireCrudNamespace" } = {}) {
-  const normalizedNamespace = normalizeCrudNamespace(namespace);
-  if (!normalizedNamespace) {
-    throw new TypeError(`${context} requires a non-empty namespace.`);
-  }
-
-  return normalizedNamespace;
-}
-
-function resolveCrudRecordChangedEvent(namespace = "") {
-  const normalizedNamespace = requireCrudNamespace(namespace, {
-    context: "resolveCrudRecordChangedEvent"
-  });
-  return `${normalizedNamespace.replace(/-/g, "_")}.record.changed`;
-}
-
 export {
   normalizeCrudNamespace,
   requireCrudNamespace,
   resolveCrudRecordChangedEvent
-};
+} from "@jskit-ai/resource-crud-core/shared/crudNamespaceSupport";

package/src/shared/crudResource.js

@@ -0,0 +1 @@
+export { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";

package/test/createCrudServiceFromResource.test.js

@@ -1,30 +1,35 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createSchema } from "json-rest-schema";
 import { createCrudServiceFromResource } from "../src/server/createCrudServiceFromResource.js";
 
+function createOperationSchemaDefinition(structure = {}, mode = "replace") {
+  return {
+    schema: createSchema(structure),
+    mode
+  };
+}
+
 function createResourceWithOutputSchema(overrides = {}) {
   return {
     namespace: "contacts",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              name: { type: "string" },
-              optionalSecret: { type: "string" },
-              nullableSecret: {
-                anyOf: [{ type: "string" }, { type: "null" }]
-              },
-              defaultedSecret: {
-                type: "string",
-                default: ""
-              }
-            },
-            required: ["id", "name", "nullableSecret", "defaultedSecret"]
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          name: { type: "string", required: true },
+          optionalSecret: { type: "string", required: false },
+          nullableSecret: {
+            type: "string",
+            required: true,
+            nullable: true
+          },
+          defaultedSecret: {
+            type: "string",
+            required: true,
+            default: ""
           }
-        }
+        })
       }
     },
     ...overrides
@@ -225,7 +230,7 @@ test("createCrudServiceFromResource readable field hooks require view output sch
 
   await assert.rejects(
     () => service.getRecord(1, {}),
-    /requires resource\.operations\.view\.outputValidator\.schema for fieldAccess\.readable/
+    /requires resource\.operations\.view\.output for fieldAccess\.readable/
   );
 });
 
@@ -307,15 +312,12 @@ test("createCrudServiceFromResource readable filtering fails fast for required n
     namespace: "contacts",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              strictSecret: { type: "string" }
-            },
-            required: ["id", "strictSecret"]
-          }
+        output: {
+          schema: createSchema({
+            id: { type: "integer", required: true },
+            strictSecret: { type: "string", required: true }
+          }),
+          mode: "replace"
         }
       }
     }
@@ -334,6 +336,6 @@ test("createCrudServiceFromResource readable filtering fails fast for required n
 
   await assert.rejects(
     () => service.getRecord(1, {}),
-    /cannot redact required non-nullable field "strictSecret" without schema\.default/
+    /cannot redact required non-nullable field "strictSecret" without a default value/
   );
 });

package/test/{crudFieldMetaSupport.test.js → crudFieldSupport.test.js}

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import {
   checkCrudLookupFormControl,
   isCrudRuntimeOutputOnlyFieldKey
-} from "../src/shared/crudFieldMetaSupport.js";
+} from "../src/shared/crudFieldSupport.js";
 
 test("checkCrudLookupFormControl defaults to autocomplete", () => {
   assert.equal(checkCrudLookupFormControl(undefined), "autocomplete");

package/test/crudModuleConfig.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveCrudSurfacePolicyFromAppConfig } from "../src/server/crudModuleConfig.js";
+
+test("resolveCrudSurfacePolicyFromAppConfig explains missing workspace surfaces for workspace-capable tenancy", () => {
+  assert.throws(
+    () =>
+      resolveCrudSurfacePolicyFromAppConfig(
+        {
+          namespace: "users",
+          surface: "admin",
+          ownershipFilter: "public",
+          relativePath: "/users"
+        },
+        {
+          tenancyMode: "personal",
+          surfaceDefaultId: "home",
+          surfaceDefinitions: {
+            home: {
+              id: "home",
+              enabled: true,
+              requiresAuth: false,
+              requiresWorkspace: false
+            }
+          }
+        },
+        {
+          context: "UsersProvider"
+        }
+      ),
+    /UsersProvider cannot resolve surface "admin".*@jskit-ai\/workspaces-core.*"app" and "admin" surfaces/s
+  );
+});