@jskit-ai/crud-core 0.1.53 → 0.1.55

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-core",
-  version: "0.1.53",
+  version: "0.1.55",
   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.53"
+        "@jskit-ai/crud-core": "0.1.55"
       },
       dev: {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-core",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -13,10 +13,9 @@
     "./shared/crudFieldMetaSupport": "./src/shared/crudFieldMetaSupport.js",
     "./shared/crudNamespaceSupport": "./src/shared/crudNamespaceSupport.js",
     "./server/repositorySupport": "./src/server/repositorySupport.js",
-    "./server/repositoryMethods": "./src/server/repositoryMethods.js",
+    "./server/resourceRuntime": "./src/server/resourceRuntime/index.js",
     "./server/createHooksToCollectChildren": "./src/server/createHooksToCollectChildren.js",
-    "./server/createCrudRepositoryFromResource": "./src/server/createCrudRepositoryFromResource.js",
-    "./server/lookupProviders": "./src/server/lookupProviders.js",
+    "./server/lookups": "./src/server/lookups.js",
     "./server/serviceEvents": "./src/server/serviceEvents.js",
     "./server/serviceMethods": "./src/server/serviceMethods.js",
     "./server/fieldAccess": "./src/server/fieldAccess.js",
@@ -27,12 +26,12 @@
   },
   "dependencies": {
     "@tanstack/vue-query": "^5.90.5",
-    "@jskit-ai/database-runtime": "0.1.45",
-    "@jskit-ai/kernel": "0.1.45",
-    "@jskit-ai/realtime": "0.1.44",
-    "@jskit-ai/shell-web": "0.1.44",
-    "@jskit-ai/users-core": "0.1.55",
-    "@jskit-ai/users-web": "0.1.60",
+    "@jskit-ai/database-runtime": "0.1.47",
+    "@jskit-ai/kernel": "0.1.47",
+    "@jskit-ai/realtime": "0.1.46",
+    "@jskit-ai/shell-web": "0.1.46",
+    "@jskit-ai/users-core": "0.1.57",
+    "@jskit-ai/users-web": "0.1.62",
     "typebox": "^1.0.81"
   }
 }

package/src/server/lookupHydration.js

@@ -11,13 +11,13 @@ import { normalizeCrudLookupApiPath } from "./lookupPathSupport.js";
 const DEFAULT_LOOKUP_INCLUDE = "*";
 const DEFAULT_LOOKUP_MAX_DEPTH = 3;
 const MAX_LOOKUP_MAX_DEPTH = 10;
-const LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES = Object.freeze([
+const LOOKUP_OWNERSHIP_FILTER_VALUES = Object.freeze([
   "public",
   "user",
   "workspace",
   "workspace_user"
 ]);
-const LOOKUP_PROVIDER_OWNERSHIP_FILTER_SET = new Set(LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES);
+const LOOKUP_OWNERSHIP_FILTER_SET = new Set(LOOKUP_OWNERSHIP_FILTER_VALUES);
 
 function normalizeLookupRelationEntry(entry = {}, outputKeys = new Set()) {
   if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
@@ -162,7 +162,7 @@ function createCrudLookupRuntime(resource = {}, { outputKeys = [] } = {}) {
     context: "crud lookup runtime container key"
   });
   const namespace =
-    normalizeCrudLookupNamespace(resource?.resource) ||
+    normalizeCrudLookupNamespace(resource?.namespace) ||
     normalizeCrudLookupNamespace(resource?.apiPath);
   const defaults = resolveLookupRuntimeDefaults(resource);
 
@@ -374,10 +374,10 @@ function buildLookupHydrationPlan(
   };
 }
 
-function resolveLookupProviderResolver(repositoryOptions = {}, callOptions = {}, { context = "crudRepository" } = {}) {
-  const resolver = callOptions?.resolveLookupProvider || repositoryOptions?.resolveLookupProvider;
+function resolveLookupResolver(repositoryOptions = {}, callOptions = {}, { context = "crudRepository" } = {}) {
+  const resolver = callOptions?.resolveLookup || repositoryOptions?.resolveLookup;
   if (typeof resolver !== "function") {
-    throw new TypeError(`${context} requires resolveLookupProvider(relation) to hydrate lookups.`);
+    throw new TypeError(`${context} requires resolveLookup(relation) to hydrate lookups.`);
   }
   return resolver;
 }
@@ -477,28 +477,28 @@ function resolveGroupChildInclude(group = {}) {
   return [...includeSet].join(",");
 }
 
-function normalizeLookupProvider(provider, relation = {}, { context = "crudRepository" } = {}) {
+function normalizeLookup(provider, relation = {}, { context = "crudRepository" } = {}) {
   if (!provider || typeof provider !== "object" || Array.isArray(provider)) {
-    throw new Error(`${context} could not resolve lookup provider for namespace "${relation.namespace}".`);
+    throw new Error(`${context} could not resolve lookup "${relation.namespace}".`);
   }
   if (typeof provider.listByIds !== "function") {
-    throw new Error(`${context} lookup provider for namespace "${relation.namespace}" must expose listByIds(ids, options).`);
+    throw new Error(`${context} lookup "${relation.namespace}" must expose listByIds(ids, options).`);
   }
   return provider;
 }
 
-function resolveLookupProviderOwnershipFilter(provider = {}, { context = "crudRepository" } = {}) {
+function resolveLookupOwnershipFilter(provider = {}, { context = "crudRepository" } = {}) {
   const normalizedOwnershipFilter = normalizeText(provider?.ownershipFilter).toLowerCase();
   if (!normalizedOwnershipFilter) {
     return "";
   }
 
-  if (LOOKUP_PROVIDER_OWNERSHIP_FILTER_SET.has(normalizedOwnershipFilter)) {
+  if (LOOKUP_OWNERSHIP_FILTER_SET.has(normalizedOwnershipFilter)) {
     return normalizedOwnershipFilter;
   }
 
   throw new TypeError(
-    `${context} lookup provider ownershipFilter must be one of: ${LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES.join(", ")}.`
+    `${context} lookup ownershipFilter must be one of: ${LOOKUP_OWNERSHIP_FILTER_VALUES.join(", ")}.`
   );
 }
 
@@ -509,26 +509,26 @@ function resolveLookupVisibilityContext(
   { context = "crudRepository" } = {}
 ) {
   const parentVisibilityContext = normalizeVisibilityContext(callOptions?.visibilityContext);
-  const providerOwnershipFilter = resolveLookupProviderOwnershipFilter(provider, {
+  const lookupOwnershipFilter = resolveLookupOwnershipFilter(provider, {
     context
   });
 
-  if (!providerOwnershipFilter) {
+  if (!lookupOwnershipFilter) {
     if (parentVisibilityContext.visibility !== "public") {
       throw new Error(
-        `${context} lookup provider for namespace "${relation.namespace}" must declare ownershipFilter when parent visibility is "${parentVisibilityContext.visibility}".`
+        `${context} lookup "${relation.namespace}" must declare ownershipFilter when parent visibility is "${parentVisibilityContext.visibility}".`
       );
     }
     return callOptions?.visibilityContext;
   }
 
   const nextVisibilityContext = {
-    visibility: providerOwnershipFilter
+    visibility: lookupOwnershipFilter
   };
-  if (providerOwnershipFilter === "workspace" || providerOwnershipFilter === "workspace_user") {
+  if (lookupOwnershipFilter === "workspace" || lookupOwnershipFilter === "workspace_user") {
     nextVisibilityContext.scopeOwnerId = parentVisibilityContext.scopeOwnerId;
   }
-  if (providerOwnershipFilter === "user" || providerOwnershipFilter === "workspace_user") {
+  if (lookupOwnershipFilter === "user" || lookupOwnershipFilter === "workspace_user") {
     nextVisibilityContext.userId = parentVisibilityContext.userId;
   }
 
@@ -624,7 +624,7 @@ async function hydrateCrudLookupRecords(
     return sourceRecords;
   }
 
-  const resolveLookupProvider = resolveLookupProviderResolver(repositoryOptions, callOptions, {
+  const resolveLookup = resolveLookupResolver(repositoryOptions, callOptions, {
     context: runtime?.context || "crudRepository"
   });
 
@@ -636,7 +636,7 @@ async function hydrateCrudLookupRecords(
       continue;
     }
 
-    const provider = normalizeLookupProvider(resolveLookupProvider(group.relation), group.relation, {
+    const provider = normalizeLookup(resolveLookup(group.relation), group.relation, {
       context: runtime?.context || "crudRepository"
     });
     const childVisibilityContext = resolveLookupVisibilityContext(

package/src/server/lookupPathSupport.js

@@ -4,7 +4,7 @@ import {
 } from "@jskit-ai/kernel/shared/support/crudLookup";
 import { toSnakeCase } from "@jskit-ai/kernel/shared/support/stringCase";
 
-function requireCrudLookupNamespace(value = "", { context = "crudLookupProvider" } = {}) {
+function requireCrudLookupNamespace(value = "", { context = "crudLookup" } = {}) {
   const normalizedNamespace = normalizeCrudLookupNamespace(value);
   if (!normalizedNamespace) {
     throw new Error(`${context} requires relation.namespace.`);
@@ -13,7 +13,7 @@ function requireCrudLookupNamespace(value = "", { context = "crudLookupProvider"
   return normalizedNamespace;
 }
 
-function resolveCrudLookupProviderToken(namespace = "", { context = "crudLookupProvider" } = {}) {
+function resolveCrudLookupToken(namespace = "", { context = "crudLookup" } = {}) {
   const normalizedNamespace = requireCrudLookupNamespace(namespace, {
     context
   });
@@ -22,10 +22,10 @@ function resolveCrudLookupProviderToken(namespace = "", { context = "crudLookupP
     .map((segment) => toSnakeCase(segment))
     .filter(Boolean)
     .join(".");
-  return `crud.lookup.${tokenPart}`;
+  return `lookup.${tokenPart}`;
 }
 
-function resolveCrudLookupNamespaceFromRelation(relation = {}, { context = "crudLookupProvider" } = {}) {
+function resolveCrudLookupNamespaceFromRelation(relation = {}, { context = "crudLookup" } = {}) {
   const normalizedNamespace =
     normalizeCrudLookupNamespace(relation?.namespace) ||
     normalizeCrudLookupNamespace(relation?.apiPath);
@@ -41,5 +41,5 @@ export {
   normalizeCrudLookupNamespace,
   requireCrudLookupNamespace,
   resolveCrudLookupNamespaceFromRelation,
-  resolveCrudLookupProviderToken
+  resolveCrudLookupToken
 };

package/src/server/{lookupProviders.js → lookups.js}

@@ -1,55 +1,55 @@
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
-  resolveCrudLookupProviderToken,
+  resolveCrudLookupToken,
   resolveCrudLookupNamespaceFromRelation
 } from "./lookupPathSupport.js";
 
-const LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES = Object.freeze([
+const LOOKUP_OWNERSHIP_FILTER_VALUES = Object.freeze([
   "public",
   "user",
   "workspace",
   "workspace_user"
 ]);
-const LOOKUP_PROVIDER_OWNERSHIP_FILTER_SET = new Set(LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES);
+const LOOKUP_OWNERSHIP_FILTER_SET = new Set(LOOKUP_OWNERSHIP_FILTER_VALUES);
 
-function normalizeLookupProviderOwnershipFilter(value, { context = "crudLookupProvider ownershipFilter" } = {}) {
+function normalizeLookupOwnershipFilter(value, { context = "crudLookup ownershipFilter" } = {}) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) {
     return "";
   }
 
-  if (LOOKUP_PROVIDER_OWNERSHIP_FILTER_SET.has(normalized)) {
+  if (LOOKUP_OWNERSHIP_FILTER_SET.has(normalized)) {
     return normalized;
   }
 
   throw new TypeError(
-    `${context} must be one of: ${LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES.join(", ")}.`
+    `${context} must be one of: ${LOOKUP_OWNERSHIP_FILTER_VALUES.join(", ")}.`
   );
 }
 
-function createCrudLookupProviderResolver(scope, { context = "crudLookupProvider" } = {}) {
+function createCrudLookupResolver(scope, { context = "crudLookup" } = {}) {
   if (!scope || typeof scope.make !== "function") {
     throw new Error(`${context} requires scope.make().`);
   }
 
-  return function resolveLookupProvider(relation = {}) {
+  return function resolveLookup(relation = {}) {
     const namespace = resolveCrudLookupNamespaceFromRelation(relation, {
       context
     });
     return scope.make(
-      resolveCrudLookupProviderToken(namespace, {
+      resolveCrudLookupToken(namespace, {
         context
       })
     );
   };
 }
 
-function createCrudLookupProvider(repository, { context = "crudLookupProvider", ownershipFilter = "" } = {}) {
+function createCrudLookup(repository, { context = "crudLookup", ownershipFilter = "" } = {}) {
   if (!repository || typeof repository.listByIds !== "function") {
     throw new Error(`${context} requires repository.listByIds(ids, options).`);
   }
 
-  const normalizedOwnershipFilter = normalizeLookupProviderOwnershipFilter(
+  const normalizedOwnershipFilter = normalizeLookupOwnershipFilter(
     ownershipFilter || repository?.ownershipFilter,
     {
       context: `${context} ownershipFilter`
@@ -69,7 +69,7 @@ function createCrudLookupProvider(repository, { context = "crudLookupProvider",
 }
 
 export {
-  resolveCrudLookupProviderToken,
-  createCrudLookupProviderResolver,
-  createCrudLookupProvider
+  resolveCrudLookupToken,
+  createCrudLookupResolver,
+  createCrudLookup
 };

package/src/server/repositorySupport.js

@@ -8,7 +8,12 @@ import {
   resolveCrudLookupContainerKey,
   resolveCrudLookupFieldKeys
 } from "@jskit-ai/kernel/shared/support/crudLookup";
-import { isCrudRuntimeOutputOnlyFieldKey } from "../shared/crudFieldMetaSupport.js";
+import {
+  CRUD_FIELD_REPOSITORY_STORAGE_COLUMN,
+  CRUD_FIELD_REPOSITORY_STORAGE_VIRTUAL,
+  isCrudRuntimeOutputOnlyFieldKey,
+  normalizeCrudFieldRepositoryConfig
+} from "../shared/crudFieldMetaSupport.js";
 
 const DEFAULT_LIST_LIMIT = 20;
 const MAX_LIST_LIMIT = 100;
@@ -70,7 +75,8 @@ function resolveColumnName(fieldKey, overrides = {}) {
 function buildRepositoryColumnMetadata({
   outputKeys = [],
   writeKeys = [],
-  columnOverrides = {}
+  columnOverrides = {},
+  fieldStorageByKey = {}
 } = {}) {
   const normalizedOutputKeys = (Array.isArray(outputKeys) ? outputKeys : [])
     .map((key) => String(key || "").trim())
@@ -80,6 +86,9 @@ function buildRepositoryColumnMetadata({
     .filter(Boolean);
 
   const deriveMapping = (key) => {
+    if (fieldStorageByKey?.[key] !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+      return null;
+    }
     const column = resolveColumnName(key, columnOverrides);
     if (!column) {
       return null;
@@ -100,6 +109,13 @@ function buildRepositoryColumnMetadata({
   });
 }
 
+function resolveOptionalObjectSchemaProperties(schema, options = {}) {
+  if (!schema) {
+    return {};
+  }
+  return requireObjectSchemaProperties(schema, options);
+}
+
 function requireObjectSchemaProperties(schema, { context = "crudRepository", schemaLabel = "schema" } = {}) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     throw new TypeError(`${context} requires ${schemaLabel} to be an object schema.`);
@@ -189,6 +205,7 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
 
   const outputSchema = operations?.view?.outputValidator?.schema;
   const writeSchema = operations?.create?.bodyValidator?.schema;
+  const patchSchema = operations?.patch?.bodyValidator?.schema;
   const outputProperties = requireObjectSchemaProperties(outputSchema, {
     context,
     schemaLabel: "operations.view.outputValidator.schema"
@@ -197,6 +214,10 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
     context,
     schemaLabel: "operations.create.bodyValidator.schema"
   });
+  const patchProperties = resolveOptionalObjectSchemaProperties(patchSchema, {
+    context,
+    schemaLabel: "operations.patch.bodyValidator.schema"
+  });
   const lookupContainerKey = resolveCrudLookupContainerKey(resource, {
     context: `${context} resource.contract.lookup.containerKey`
   });
@@ -205,20 +226,63 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
       (key) => !isCrudRuntimeOutputOnlyFieldKey(key, { lookupContainerKey })
     )
   );
-  const writeKeys = Object.freeze(Object.keys(writeProperties));
+  const writeKeys = Object.freeze([
+    ...Object.keys(writeProperties),
+    ...Object.keys(patchProperties).filter((key) => !Object.hasOwn(writeProperties, key))
+  ]);
 
+  const fieldStorageByKey = {};
   const columnOverrides = {};
   for (const entry of normalizeResourceFieldMetaEntries(resource.fieldMeta)) {
     const key = normalizeText(entry.key);
-    const dbColumn = normalizeText(entry.dbColumn);
-    if (!key || !dbColumn) {
+    if (!key) {
       continue;
     }
-    columnOverrides[key] = dbColumn;
+    const repositoryConfig = normalizeCrudFieldRepositoryConfig(entry, {
+      context: `${context} resource.fieldMeta`,
+      fieldKey: key
+    });
+    fieldStorageByKey[key] = repositoryConfig.storage;
+    if (repositoryConfig.column) {
+      columnOverrides[key] = repositoryConfig.column;
+    }
+  }
+
+  for (const key of [...outputKeys, ...writeKeys]) {
+    if (!fieldStorageByKey[key]) {
+      fieldStorageByKey[key] = CRUD_FIELD_REPOSITORY_STORAGE_COLUMN;
+    }
+  }
+
+  const virtualOutputKeys = [];
+  const columnBackedOutputKeys = [];
+  for (const key of outputKeys) {
+    const storage = fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN;
+    if (storage === CRUD_FIELD_REPOSITORY_STORAGE_VIRTUAL) {
+      virtualOutputKeys.push(key);
+      continue;
+    }
+    columnBackedOutputKeys.push(key);
+  }
+
+  for (const key of virtualOutputKeys) {
+    if (Object.hasOwn(writeProperties, key)) {
+      throw new Error(
+        `${context} resource create schema field "${key}" cannot use repository.storage "virtual".`
+      );
+    }
+    if (Object.hasOwn(patchProperties, key)) {
+      throw new Error(
+        `${context} resource patch schema field "${key}" cannot use repository.storage "virtual".`
+      );
+    }
   }
 
   const listSearchColumns = [];
   for (const [key, schema] of Object.entries(outputProperties)) {
+    if ((fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+      continue;
+    }
     if (!schemaIncludesStringType(schema)) {
       continue;
     }
@@ -232,6 +296,9 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
 
   const parentFilterColumns = {};
   for (const key of resolveCrudLookupFieldKeys(resource, { allowKeys: writeKeys })) {
+    if ((fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+      continue;
+    }
     const columnName = resolveColumnName(key, columnOverrides);
     if (!columnName) {
       continue;
@@ -249,7 +316,10 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
   return Object.freeze({
     outputKeys,
     writeKeys,
+    fieldStorageByKey: Object.freeze(fieldStorageByKey),
     columnOverrides: Object.freeze(columnOverrides),
+    columnBackedOutputKeys: Object.freeze(columnBackedOutputKeys),
+    virtualOutputKeys: Object.freeze(virtualOutputKeys),
     listSearchColumns: Object.freeze(listSearchColumns),
     parentFilterColumns: Object.freeze(parentFilterColumns),
     outputRecordIdKeys: Object.freeze(outputRecordIdKeys)