@jskit-ai/crud-core 0.1.30 → 0.1.32

package/package.descriptor.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-core",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -14,9 +14,11 @@
     "./shared/crudNamespaceSupport": "./src/shared/crudNamespaceSupport.js",
     "./server/repositorySupport": "./src/server/repositorySupport.js",
     "./server/repositoryMethods": "./src/server/repositoryMethods.js",
+    "./server/createHooksToCollectChildren": "./src/server/createHooksToCollectChildren.js",
     "./server/createCrudRepositoryFromResource": "./src/server/createCrudRepositoryFromResource.js",
     "./server/lookupProviders": "./src/server/lookupProviders.js",
     "./server/serviceEvents": "./src/server/serviceEvents.js",
+    "./server/serviceMethods": "./src/server/serviceMethods.js",
     "./server/fieldAccess": "./src/server/fieldAccess.js",
     "./server/createCrudServiceFromResource": "./src/server/createCrudServiceFromResource.js",
     "./server/crudModuleConfig": "./src/server/crudModuleConfig.js",
@@ -24,11 +26,11 @@
   },
   "dependencies": {
     "@tanstack/vue-query": "^5.90.5",
-    "@jskit-ai/kernel": "0.1.22",
-    "@jskit-ai/realtime": "0.1.21",
-    "@jskit-ai/shell-web": "0.1.21",
-    "@jskit-ai/users-core": "0.1.31",
-    "@jskit-ai/users-web": "0.1.36",
+    "@jskit-ai/kernel": "0.1.24",
+    "@jskit-ai/realtime": "0.1.23",
+    "@jskit-ai/shell-web": "0.1.23",
+    "@jskit-ai/users-core": "0.1.33",
+    "@jskit-ai/users-web": "0.1.38",
     "typebox": "^1.0.81"
   }
 }

package/src/server/createCrudRepositoryFromResource.js

@@ -3,6 +3,7 @@ import {
   crudRepositoryList,
   crudRepositoryFindById,
   crudRepositoryListByIds,
+  crudRepositoryListByForeignIds,
   crudRepositoryCreate,
   crudRepositoryUpdateById,
   crudRepositoryDeleteById
@@ -19,34 +20,39 @@ function createCrudRepositoryFromResource(resource = {}, { context = "crudReposi
       throw new TypeError("crudRepository requires knex.");
     }
 
-    async function listRecords(query = {}, callOptions = {}) {
-      return crudRepositoryList(runtime, knex, query, options, callOptions);
+    async function listRecords(query = {}, callOptions = {}, hooks = null) {
+      return crudRepositoryList(runtime, knex, query, options, callOptions, hooks);
     }
 
-    async function findById(recordId, callOptions = {}) {
-      return crudRepositoryFindById(runtime, knex, recordId, options, callOptions);
+    async function findById(recordId, callOptions = {}, hooks = null) {
+      return crudRepositoryFindById(runtime, knex, recordId, options, callOptions, hooks);
     }
 
-    async function listByIds(ids = [], callOptions = {}) {
-      return crudRepositoryListByIds(runtime, knex, ids, options, callOptions);
+    async function listByIds(ids = [], callOptions = {}, hooks = null) {
+      return crudRepositoryListByIds(runtime, knex, ids, options, callOptions, hooks);
     }
 
-    async function create(payload = {}, callOptions = {}) {
-      return crudRepositoryCreate(runtime, knex, payload, options, callOptions);
+    async function listByForeignIds(ids = [], foreignKey = "", callOptions = {}, hooks = null) {
+      return crudRepositoryListByForeignIds(runtime, knex, ids, foreignKey, options, callOptions, hooks);
     }
 
-    async function updateById(recordId, patch = {}, callOptions = {}) {
-      return crudRepositoryUpdateById(runtime, knex, recordId, patch, options, callOptions);
+    async function create(payload = {}, callOptions = {}, hooks = null) {
+      return crudRepositoryCreate(runtime, knex, payload, options, callOptions, hooks);
     }
 
-    async function deleteById(recordId, callOptions = {}) {
-      return crudRepositoryDeleteById(runtime, knex, recordId, options, callOptions);
+    async function updateById(recordId, patch = {}, callOptions = {}, hooks = null) {
+      return crudRepositoryUpdateById(runtime, knex, recordId, patch, options, callOptions, hooks);
+    }
+
+    async function deleteById(recordId, callOptions = {}, hooks = null) {
+      return crudRepositoryDeleteById(runtime, knex, recordId, options, callOptions, hooks);
     }
 
     return Object.freeze({
       list: listRecords,
       findById,
       listByIds,
+      listByForeignIds,
       create,
       updateById,
       deleteById

package/src/server/createCrudServiceFromResource.js

@@ -1,12 +1,16 @@
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { requireCrudNamespace } from "../shared/crudNamespaceSupport.js";
-import { createCrudFieldAccessRuntime } from "./fieldAccess.js";
 import { createCrudServiceEvents } from "./serviceEvents.js";
+import {
+  createCrudServiceRuntime,
+  crudServiceListRecords,
+  crudServiceGetRecord,
+  crudServiceCreateRecord,
+  crudServiceUpdateRecord,
+  crudServiceDeleteRecord
+} from "./serviceMethods.js";
 
 function createCrudServiceFromResource(resource = {}, { context = "crudService" } = {}) {
-  const namespace = requireCrudNamespace(resource?.resource, { context: `${context} resource.resource` });
+  const runtime = createCrudServiceRuntime(resource, { context });
   const baseServiceEvents = createCrudServiceEvents(resource, { context });
-  const fieldAccessRuntime = createCrudFieldAccessRuntime(resource, { context });
 
   function createBaseService({ repository, fieldAccess = {} } = {}) {
     if (!repository) {
@@ -14,73 +18,23 @@ function createCrudServiceFromResource(resource = {}, { context = "crudService"
     }
 
     async function listRecords(query = {}, options = {}) {
-      const result = await repository.list(query, options);
-      return fieldAccessRuntime.filterReadableListResult(result, fieldAccess, {
-        action: "list",
-        query,
-        options,
-        context: options?.context
-      });
+      return crudServiceListRecords(runtime, repository, fieldAccess, query, options);
     }
 
     async function getRecord(recordId, options = {}) {
-      const record = await repository.findById(recordId, options);
-      if (!record) {
-        throw new AppError(404, "Record not found.");
-      }
-
-      return fieldAccessRuntime.filterReadableRecord(record, fieldAccess, {
-        action: "view",
-        recordId,
-        options,
-        context: options?.context
-      });
+      return crudServiceGetRecord(runtime, repository, fieldAccess, recordId, options);
     }
 
     async function createRecord(payload = {}, options = {}) {
-      const writablePayload = await fieldAccessRuntime.enforceWritablePayload(payload, fieldAccess, {
-        action: "create",
-        payload,
-        options,
-        context: options?.context
-      });
-      const record = await repository.create(writablePayload, options);
-      if (!record) {
-        throw new Error(`${namespace}Service could not load the created record.`);
-      }
-      return fieldAccessRuntime.filterReadableRecord(record, fieldAccess, {
-        action: "create",
-        options,
-        context: options?.context
-      });
+      return crudServiceCreateRecord(runtime, repository, fieldAccess, payload, options);
     }
 
     async function updateRecord(recordId, payload = {}, options = {}) {
-      const writablePayload = await fieldAccessRuntime.enforceWritablePayload(payload, fieldAccess, {
-        action: "update",
-        recordId,
-        payload,
-        options,
-        context: options?.context
-      });
-      const record = await repository.updateById(recordId, writablePayload, options);
-      if (!record) {
-        throw new AppError(404, "Record not found.");
-      }
-      return fieldAccessRuntime.filterReadableRecord(record, fieldAccess, {
-        action: "update",
-        recordId,
-        options,
-        context: options?.context
-      });
+      return crudServiceUpdateRecord(runtime, repository, fieldAccess, recordId, payload, options);
     }
 
     async function deleteRecord(recordId, options = {}) {
-      const deleted = await repository.deleteById(recordId, options);
-      if (!deleted) {
-        throw new AppError(404, "Record not found.");
-      }
-      return deleted;
+      return crudServiceDeleteRecord(runtime, repository, fieldAccess, recordId, options);
     }
 
     return Object.freeze({

package/src/server/createHooksToCollectChildren.js

@@ -0,0 +1,247 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function normalizeOwnerKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : "";
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+
+  return String(value).trim();
+}
+
+function toDefaultChildCallOptions(callOptions = {}) {
+  const nextOptions = {};
+  if (Object.hasOwn(callOptions, "trx")) {
+    nextOptions.trx = callOptions.trx;
+  }
+  if (Object.hasOwn(callOptions, "visibilityContext")) {
+    nextOptions.visibilityContext = callOptions.visibilityContext;
+  }
+
+  return nextOptions;
+}
+
+function resolveListChildrenHandler(options = {}, { context = "createHooksToCollectChildren" } = {}) {
+  if (typeof options.listChildren === "function") {
+    return options.listChildren;
+  }
+
+  const childRepository = options.childRepository;
+  const childListMethod = normalizeText(options.childListMethod) || "listByIds";
+  const childForeignKey = normalizeText(options.childForeignKey);
+  if (!childRepository || typeof childRepository !== "object" || Array.isArray(childRepository)) {
+    throw new TypeError(
+      `${context} requires listChildren(ids, options, ctx) or childRepository.`
+    );
+  }
+
+  const listChildren = childRepository[childListMethod];
+  if (typeof listChildren !== "function") {
+    throw new TypeError(`${context} requires childRepository.${childListMethod} to be a function.`);
+  }
+
+  if (childListMethod === "listByIds") {
+    if (!childForeignKey) {
+      throw new TypeError(`${context} requires childForeignKey when using childRepository.listByIds.`);
+    }
+
+    return (ids = [], childCallOptions = {}, hookContext = {}) =>
+      listChildren.call(childRepository, ids, {
+        ...childCallOptions,
+        valueKey: childForeignKey
+      }, hookContext);
+  }
+
+  if (childListMethod === "listByForeignIds") {
+    if (!childForeignKey) {
+      throw new TypeError(`${context} requires childForeignKey when using childRepository.listByForeignIds.`);
+    }
+
+    return (ids = [], childCallOptions = {}, hookContext = {}) =>
+      listChildren.call(childRepository, ids, childForeignKey, childCallOptions, hookContext);
+  }
+
+  return (ids = [], childCallOptions = {}, hookContext = {}) => {
+    if (childForeignKey) {
+      return listChildren.call(childRepository, ids, childForeignKey, childCallOptions, hookContext);
+    }
+    return listChildren.call(childRepository, ids, childCallOptions, hookContext);
+  };
+}
+
+function resolveGetChildOwnerId(options = {}, { context = "createHooksToCollectChildren" } = {}) {
+  if (typeof options.getChildOwnerId === "function") {
+    return options.getChildOwnerId;
+  }
+
+  const childOwnerIdKey = normalizeText(options.childOwnerIdKey);
+  const childForeignKey = normalizeText(options.childForeignKey);
+  const ownerKey = childOwnerIdKey || childForeignKey;
+  if (!ownerKey) {
+    throw new TypeError(`${context} requires childOwnerIdKey, childForeignKey, or getChildOwnerId.`);
+  }
+
+  return (child = {}) => {
+    if (!child || typeof child !== "object" || Array.isArray(child)) {
+      return undefined;
+    }
+    if (childOwnerIdKey && Object.hasOwn(child, childOwnerIdKey)) {
+      return child[childOwnerIdKey];
+    }
+    return child[ownerKey];
+  };
+}
+
+function resolveLookupContainerKey(record = {}, hookContext = {}, options = {}) {
+  const explicitContainerKey = normalizeText(options.lookupContainerKey);
+  if (explicitContainerKey) {
+    return explicitContainerKey;
+  }
+
+  const runtimeContainerKey = normalizeText(hookContext?.runtime?.lookup?.containerKey);
+  if (runtimeContainerKey) {
+    return runtimeContainerKey;
+  }
+
+  if (Object.hasOwn(record, "lookups")) {
+    return "lookups";
+  }
+
+  return "lookups";
+}
+
+function createHooksToCollectChildren(options = {}) {
+  const context = normalizeText(options.context) || "createHooksToCollectChildren";
+  const childKey = normalizeText(options.childKey);
+  if (!childKey) {
+    throw new TypeError(`${context} requires childKey.`);
+  }
+
+  const listChildren = resolveListChildrenHandler(options, {
+    context
+  });
+  const getParentId = typeof options.getParentId === "function"
+    ? options.getParentId
+    : (record = {}) => record?.id;
+  const getChildOwnerId = resolveGetChildOwnerId(options, {
+    context
+  });
+  const normalizeCollectionOwnerKey = typeof options.normalizeOwnerKey === "function"
+    ? options.normalizeOwnerKey
+    : normalizeOwnerKey;
+  const buildChildCallOptions = typeof options.buildChildCallOptions === "function"
+    ? options.buildChildCallOptions
+    : ({ callOptions = {} } = {}) => toDefaultChildCallOptions(callOptions);
+  const stateMapKey = options.stateMapKey || Symbol(`crud.children.${childKey}`);
+  const attachToLookupContainer = options.attachToLookupContainer !== false;
+  const attachChildren = typeof options.attachChildren === "function"
+    ? options.attachChildren
+    : (record = {}, children = [], hookContext = {}) => {
+      if (!attachToLookupContainer) {
+        return {
+          ...record,
+          [childKey]: children
+        };
+      }
+
+      const containerKey = resolveLookupContainerKey(record, hookContext, options);
+      const sourceContainer = record?.[containerKey];
+      const normalizedContainer =
+        sourceContainer && typeof sourceContainer === "object" && !Array.isArray(sourceContainer)
+          ? sourceContainer
+          : {};
+
+      return {
+        ...record,
+        [containerKey]: {
+          ...normalizedContainer,
+          [childKey]: children
+        }
+      };
+    };
+
+  return Object.freeze({
+    async afterQuery(records = [], ctx = {}) {
+      const normalizedRecords = Array.isArray(records) ? records : [];
+      const ownerIds = [];
+      const seenOwnerKeys = new Set();
+
+      for (const record of normalizedRecords) {
+        const ownerId = getParentId(record, ctx);
+        const ownerKey = normalizeCollectionOwnerKey(ownerId);
+        if (!ownerKey || seenOwnerKeys.has(ownerKey)) {
+          continue;
+        }
+
+        seenOwnerKeys.add(ownerKey);
+        ownerIds.push(ownerId);
+      }
+
+      const state = ctx?.state && typeof ctx.state === "object" ? ctx.state : null;
+      if (!state) {
+        throw new TypeError(`${context} requires ctx.state object.`);
+      }
+
+      if (ownerIds.length < 1) {
+        state[stateMapKey] = new Map();
+        return;
+      }
+
+      const childCallOptions = buildChildCallOptions({
+        callOptions: ctx.callOptions || {},
+        records: normalizedRecords,
+        ownerIds,
+        context: ctx
+      });
+      const children = await listChildren(ownerIds, childCallOptions, ctx);
+      if (!Array.isArray(children)) {
+        throw new TypeError(`${context} listChildren must return an array.`);
+      }
+
+      const childrenByOwnerKey = new Map();
+      for (const child of children) {
+        const childOwnerId = getChildOwnerId(child, ctx);
+        const childOwnerKey = normalizeCollectionOwnerKey(childOwnerId);
+        if (!childOwnerKey) {
+          continue;
+        }
+
+        const currentList = childrenByOwnerKey.get(childOwnerKey);
+        if (currentList) {
+          currentList.push(child);
+          continue;
+        }
+
+        childrenByOwnerKey.set(childOwnerKey, [child]);
+      }
+
+      state[stateMapKey] = childrenByOwnerKey;
+    },
+
+    transformReturnedRecord(record = {}, ctx = {}) {
+      if (!record || typeof record !== "object" || Array.isArray(record)) {
+        return record;
+      }
+
+      const state = ctx?.state && typeof ctx.state === "object" ? ctx.state : null;
+      const childrenByOwnerKey = state ? state[stateMapKey] : null;
+      const ownerKey = normalizeCollectionOwnerKey(getParentId(record, ctx));
+      const children = ownerKey && childrenByOwnerKey instanceof Map
+        ? (childrenByOwnerKey.get(ownerKey) || [])
+        : [];
+
+      return attachChildren(record, children, ctx);
+    }
+  });
+}
+
+export { createHooksToCollectChildren };

package/src/server/listQueryValidators.js

@@ -1,7 +1,11 @@
 import { Type } from "typebox";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators";
+import {
+  normalizeObjectInput,
+  positiveIntegerValidator,
+  cursorPaginationQueryValidator
+} from "@jskit-ai/kernel/shared/validators";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveCrudLookupFieldKeys } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { resolveCrudParentFilterKeys as resolveSharedCrudParentFilterKeys } from "@jskit-ai/kernel/shared/support/crudLookup";
 
 const listSearchQueryValidator = Object.freeze({
   schema: Type.Object(
@@ -41,16 +45,59 @@ const lookupIncludeQueryValidator = Object.freeze({
   }
 });
 
-function resolveCrudParentFilterKeys(resource = {}) {
-  const createSchemaProperties = resource?.operations?.create?.bodyValidator?.schema?.properties;
-  const allowedKeys = createSchemaProperties && typeof createSchemaProperties === "object" && !Array.isArray(createSchemaProperties)
-    ? Object.keys(createSchemaProperties)
-    : [];
-  return resolveCrudLookupFieldKeys(resource, {
-    allowKeys: allowedKeys
+function resolveCrudListUsesOrderedCursor(list = {}) {
+  const orderBy = Array.isArray(list?.orderBy) ? list.orderBy : [];
+  for (const entry of orderBy) {
+    if (typeof entry === "string" && normalizeText(entry)) {
+      return true;
+    }
+    if (entry && typeof entry === "object" && !Array.isArray(entry) && normalizeText(entry.column)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function createCrudCursorPaginationQueryValidator(list = {}) {
+  if (resolveCrudListUsesOrderedCursor(list) !== true) {
+    return cursorPaginationQueryValidator;
+  }
+
+  return Object.freeze({
+    schema: Type.Object(
+      {
+        cursor: Type.Optional(
+          Type.Union([
+            positiveIntegerValidator.schema,
+            Type.String({ minLength: 1 })
+          ])
+        ),
+        limit: Type.Optional(positiveIntegerValidator.schema)
+      },
+      { additionalProperties: false }
+    ),
+    normalize(payload = {}) {
+      const source = normalizeObjectInput(payload);
+      const normalized = {};
+
+      if (Object.hasOwn(source, "cursor")) {
+        normalized.cursor = normalizeText(source.cursor);
+      }
+
+      if (Object.hasOwn(source, "limit")) {
+        normalized.limit = positiveIntegerValidator.normalize(source.limit);
+      }
+
+      return normalized;
+    }
   });
 }
 
+function resolveCrudParentFilterKeys(resource = {}) {
+  return resolveSharedCrudParentFilterKeys(resource);
+}
+
 function createCrudParentFilterQueryValidator(resource = {}) {
   const keys = resolveCrudParentFilterKeys(resource);
   const schemaProperties = {};
@@ -80,6 +127,7 @@ function createCrudParentFilterQueryValidator(resource = {}) {
 }
 
 export {
+  createCrudCursorPaginationQueryValidator,
   listSearchQueryValidator,
   lookupIncludeQueryValidator,
   resolveCrudParentFilterKeys,