@jskit-ai/crud-server-generator 0.1.63 → 0.1.64

package/templates/src/local-package/server/registerRoutes.js

@@ -1,23 +1,20 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import {
-  createCrudCursorPaginationQueryValidator,
-  listSearchQueryValidator,
-  lookupIncludeQueryValidator,
-  createCrudParentFilterQueryValidator
-} from "@jskit-ai/crud-core/server/listQueryValidators";
-import {
-  recordIdParamsValidator
-} from "@jskit-ai/kernel/shared/validators";
+import { createCrudJsonApiRouteContracts } from "@jskit-ai/crud-core/server/routeContracts";
 import { checkRouteVisibility } from "@jskit-ai/kernel/shared/support/visibility";
 import { resolveScopedApiBasePath } from "@jskit-ai/kernel/shared/surface";
-import { actionIds } from "./actionIds.js";
 import { resource } from "../shared/${option:namespace|singular|camel}Resource.js";
-import { LIST_CONFIG } from "./listConfig.js";
 __JSKIT_CRUD_ROUTE_WORKSPACE_SUPPORT_IMPORTS__
 
-const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator(LIST_CONFIG);
-const listParentFilterQueryValidator = createCrudParentFilterQueryValidator(resource);
+const {
+  listRouteContract,
+  viewRouteContract,
+  createRouteContract,
+  updateRouteContract,
+  deleteRouteContract,
+  recordRouteParamsValidator
+} = createCrudJsonApiRouteContracts({
+  resource__JSKIT_CRUD_ROUTE_CONTRACTS_RESOURCE_ARGS__
+});
 
 function registerRoutes(
   app,
@@ -46,23 +43,15 @@ function registerRoutes(
         tags: ["crud"],
         summary: "List records."
       },
+      ...listRouteContract,
 __JSKIT_CRUD_LIST_ROUTE_PARAMS_VALIDATOR_LINE__
-      queryValidator: [
-        listCursorPaginationQueryValidator,
-        listSearchQueryValidator,
-        listParentFilterQueryValidator,
-        lookupIncludeQueryValidator
-      ],
-      responseValidators: withStandardErrorResponses({
-        200: resource.operations.list.outputValidator
-      })
     },
     async function (request, reply) {
       const listInput = {
 __JSKIT_CRUD_LIST_ROUTE_INPUT_LINES__
       };
       const response = await request.executeAction({
-        actionId: actionIds.list,
+        actionId: "crud.${option:namespace|snake}.list",
         input: listInput
       });
       reply.code(200).send(response);
@@ -80,15 +69,12 @@ __JSKIT_CRUD_LIST_ROUTE_INPUT_LINES__
         tags: ["crud"],
         summary: "View a record."
       },
+      ...viewRouteContract,
 __JSKIT_CRUD_VIEW_ROUTE_PARAMS_VALIDATOR_LINE__
-      queryValidator: [lookupIncludeQueryValidator],
-      responseValidators: withStandardErrorResponses({
-        200: resource.operations.view.outputValidator
-      })
     },
     async function (request, reply) {
       const response = await request.executeAction({
-        actionId: actionIds.view,
+        actionId: "crud.${option:namespace|snake}.view",
         input: {
 __JSKIT_CRUD_VIEW_ROUTE_INPUT_LINES__
         }
@@ -108,18 +94,12 @@ __JSKIT_CRUD_VIEW_ROUTE_INPUT_LINES__
         tags: ["crud"],
         summary: "Create a record."
       },
+      ...createRouteContract,
 __JSKIT_CRUD_CREATE_ROUTE_PARAMS_VALIDATOR_LINE__
-      bodyValidator: resource.operations.create.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          201: resource.operations.create.outputValidator
-        },
-        { includeValidation400: true }
-      )
     },
     async function (request, reply) {
       const response = await request.executeAction({
-        actionId: actionIds.create,
+        actionId: "crud.${option:namespace|snake}.create",
         input: {
 __JSKIT_CRUD_CREATE_ROUTE_INPUT_LINES__
         }
@@ -139,18 +119,12 @@ __JSKIT_CRUD_CREATE_ROUTE_INPUT_LINES__
         tags: ["crud"],
         summary: "Update a record."
       },
+      ...updateRouteContract,
 __JSKIT_CRUD_UPDATE_ROUTE_PARAMS_VALIDATOR_LINE__
-      bodyValidator: resource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: resource.operations.patch.outputValidator
-        },
-        { includeValidation400: true }
-      )
     },
     async function (request, reply) {
       const response = await request.executeAction({
-        actionId: actionIds.update,
+        actionId: "crud.${option:namespace|snake}.update",
         input: {
 __JSKIT_CRUD_UPDATE_ROUTE_INPUT_LINES__
         }
@@ -170,19 +144,17 @@ __JSKIT_CRUD_UPDATE_ROUTE_INPUT_LINES__
         tags: ["crud"],
         summary: "Delete a record."
       },
+      ...deleteRouteContract,
 __JSKIT_CRUD_DELETE_ROUTE_PARAMS_VALIDATOR_LINE__
-      responseValidators: withStandardErrorResponses({
-        200: resource.operations.delete.outputValidator
-      })
     },
     async function (request, reply) {
       const response = await request.executeAction({
-        actionId: actionIds.delete,
+        actionId: "crud.${option:namespace|snake}.delete",
         input: {
 __JSKIT_CRUD_DELETE_ROUTE_INPUT_LINES__
         }
       });
-      reply.code(200).send(response);
+      reply.code(204).send(response);
     }
   );
 }

package/templates/src/local-package/server/repository.js

@@ -1,57 +1,101 @@
-import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
+import { createWithTransaction } from "@jskit-ai/database-runtime/shared";
+import {
+  buildJsonRestQueryParams,
+  createJsonApiInputRecord,
+  createJsonRestContext,
+  returnNullWhenJsonRestResourceMissing
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { resource } from "../shared/${option:namespace|singular|camel}Resource.js";
-import { LIST_CONFIG } from "./listConfig.js";
+const RESOURCE_TYPE = resource.namespace;
 
-const REPOSITORY_CONTEXT = "${option:namespace|snake} repository";
+function createRepository({ api, knex } = {}) {
+  const withTransaction = createWithTransaction(knex);
 
-const REPOSITORY_CONFIG = Object.freeze({
-  context: REPOSITORY_CONTEXT,
-  list: LIST_CONFIG
-});
-
-function createRepository(knex, options = {}) {
-  const resourceRuntime = createCrudResourceRuntime(resource, knex, {
-    ...options,
-    ...REPOSITORY_CONFIG
-  });
-
-  async function list(query = {}, callOptions = {}) {
-    return resourceRuntime.list(query, callOptions);
+  async function queryDocuments(query = {}, options = {}) {
+    return api.resources.${option:namespace|camel}.query(
+      {
+        queryParams: buildJsonRestQueryParams(RESOURCE_TYPE, query),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
   }
 
-  async function findById(recordId, callOptions = {}) {
-    return resourceRuntime.findById(recordId, callOptions);
+  async function getDocumentById(recordId, options = {}) {
+    return returnNullWhenJsonRestResourceMissing(() =>
+      api.resources.${option:namespace|camel}.get(
+        {
+          id: recordId,
+          queryParams: buildJsonRestQueryParams(RESOURCE_TYPE, {}, {
+            include: options?.include
+          }),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      )
+    );
   }
 
-  async function listByIds(ids = [], callOptions = {}) {
-    return resourceRuntime.listByIds(ids, callOptions);
+  async function createDocument(payload = {}, options = {}) {
+    return api.resources.${option:namespace|camel}.post(
+      {
+        inputRecord: createJsonApiInputRecord(RESOURCE_TYPE, payload),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
   }
 
-  async function listByForeignIds(ids = [], foreignKey = "", callOptions = {}) {
-    return resourceRuntime.listByForeignIds(ids, foreignKey, callOptions);
-  }
+  async function patchDocumentById(recordId, patch = {}, options = {}) {
+    const sourcePatch = patch && typeof patch === "object" && !Array.isArray(patch) ? patch : {};
+    if (Object.keys(sourcePatch).length < 1) {
+      return getDocumentById(recordId, options);
+    }
 
-  async function create(payload = {}, callOptions = {}) {
-    return resourceRuntime.create(payload, callOptions);
+    return returnNullWhenJsonRestResourceMissing(() =>
+      api.resources.${option:namespace|camel}.patch(
+        {
+          id: recordId,
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            {
+              ...sourcePatch,
+              updatedAt: new Date()
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      )
+    );
   }
 
-  async function updateById(recordId, patch = {}, callOptions = {}) {
-    return resourceRuntime.updateById(recordId, patch, callOptions);
-  }
+  async function deleteDocumentById(recordId, options = {}) {
+    return returnNullWhenJsonRestResourceMissing(async () => {
+      await api.resources.${option:namespace|camel}.delete(
+        {
+          id: recordId,
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
 
-  async function deleteById(recordId, callOptions = {}) {
-    return resourceRuntime.deleteById(recordId, callOptions);
+      return true;
+    });
   }
 
   return Object.freeze({
-    withTransaction: resourceRuntime.withTransaction,
-    list,
-    findById,
-    listByIds,
-    listByForeignIds,
-    create,
-    updateById,
-    deleteById
+    withTransaction,
+    queryDocuments,
+    getDocumentById,
+    createDocument,
+    patchDocumentById,
+    deleteDocumentById
   });
 }
 

package/templates/src/local-package/server/service.js

@@ -1,90 +1,62 @@
-import { createCrudServiceEvents } from "@jskit-ai/crud-core/server/serviceEvents";
-import {
-  createCrudServiceRuntime,
-  crudServiceListRecords,
-  crudServiceGetRecord,
-  crudServiceCreateRecord,
-  crudServiceUpdateRecord,
-  crudServiceDeleteRecord
-} from "@jskit-ai/crud-core/server/serviceMethods";
-import { resource } from "../shared/${option:namespace|singular|camel}Resource.js";
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import { returnJsonApiDocument } from "@jskit-ai/http-runtime/shared";
 
-const serviceRuntime = createCrudServiceRuntime(resource, {
-  context: "${option:namespace|camel}Service"
-});
-const baseServiceEvents = createCrudServiceEvents(resource, {
-  context: "${option:namespace|camel}Service"
-});
-
-const serviceEvents = Object.freeze({
-  createRecord: [...baseServiceEvents.createRecord],
-  updateRecord: [...baseServiceEvents.updateRecord],
-  deleteRecord: [...baseServiceEvents.deleteRecord]
-});
+function return404IfNotFound(document = null) {
+  if (!document) {
+    throw new AppError(404, "Document not found.");
+  }
+  return document;
+}
 
-const DEFAULT_FIELD_ACCESS = Object.freeze({
-  // Tip: use createFieldAccessForRoleMatrix(...) from @jskit-ai/crud-core/server/fieldAccess to centralize role matrices.
-  // Example:
-  // const DEFAULT_FIELD_ACCESS = createFieldAccessForRoleMatrix({
-  //   default: {
-  //     readable: { list: ["id", "name"], view: ["id", "name", "email"] },
-  //     writable: { create: ["name", "email"], update: ["name"] }
-  //   },
-  //   admin: {
-  //     readable: "*",
-  //     writable: "*"
-  //   },
-  //   writeMode: "throw" // or "strip"
-  // });
-  // readable: ({ action, context }) => ["id", "name"], // null/"*" means no read filtering
-  // Read redaction behavior: drop optional fields; use null/default for required fields.
-  // writable: ({ action, context }) => ["name"], // null/"*" means no write filtering
-  // writeMode: "throw" // "throw" (default) or "strip"
-});
+function createService({ ${option:namespace|camel}Repository } = {}) {
+  if (!${option:namespace|camel}Repository) {
+    throw new TypeError("createService requires ${option:namespace|camel}Repository.");
+  }
 
-function createService({ ${option:namespace|camel}Repository, fieldAccess = DEFAULT_FIELD_ACCESS } = {}) {
-  async function listRecords(query = {}, options = {}) {
-    return crudServiceListRecords(serviceRuntime, ${option:namespace|camel}Repository, fieldAccess, query, options);
+  async function queryDocuments(query = {}, options = {}) {
+    return returnJsonApiDocument(await ${option:namespace|camel}Repository.queryDocuments(query, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
   }
 
-  async function getRecord(recordId, options = {}) {
-    return crudServiceGetRecord(serviceRuntime, ${option:namespace|camel}Repository, fieldAccess, recordId, options);
+  async function getDocumentById(recordId, options = {}) {
+    return returnJsonApiDocument(return404IfNotFound(await ${option:namespace|camel}Repository.getDocumentById(recordId, {
+      trx: options?.trx || null,
+      context: options?.context || null,
+      include: options?.include
+    })));
   }
 
-  async function createRecord(payload = {}, options = {}) {
-    return crudServiceCreateRecord(serviceRuntime, ${option:namespace|camel}Repository, fieldAccess, payload, options);
+  async function createDocument(payload = {}, options = {}) {
+    return returnJsonApiDocument(await ${option:namespace|camel}Repository.createDocument(payload, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
   }
 
-  async function updateRecord(recordId, payload = {}, options = {}) {
-    return crudServiceUpdateRecord(serviceRuntime, ${option:namespace|camel}Repository, fieldAccess, recordId, payload, options);
+  async function patchDocumentById(recordId, payload = {}, options = {}) {
+    return returnJsonApiDocument(return404IfNotFound(await ${option:namespace|camel}Repository.patchDocumentById(recordId, payload, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    })));
   }
 
-  async function deleteRecord(recordId, options = {}) {
-    return crudServiceDeleteRecord(serviceRuntime, ${option:namespace|camel}Repository, fieldAccess, recordId, options);
+  async function deleteDocumentById(recordId, options = {}) {
+    return404IfNotFound(await ${option:namespace|camel}Repository.deleteDocumentById(recordId, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
+    return null;
   }
 
   return Object.freeze({
-    listRecords,
-    getRecord,
-    createRecord,
-    updateRecord,
-    deleteRecord
+    queryDocuments,
+    getDocumentById,
+    createDocument,
+    patchDocumentById,
+    deleteDocumentById
   });
 }
 
-// Optional event override example:
-// const serviceEvents = {
-//   ...baseServiceEvents,
-//   createRecord: [
-//     ...baseServiceEvents.createRecord,
-//     {
-//       type: "${option:namespace|snake}.custom",
-//       source: "custom",
-//       entity: "record",
-//       operation: "created",
-//       entityId: ({ result }) => result?.id
-//     }
-//   ]
-// };
-
-export { createService, serviceEvents };
+export { createService };

package/templates/src/local-package/shared/crudResource.js

@@ -1,91 +1,16 @@
-import { Type } from "typebox";
-__JSKIT_CRUD_RESOURCE_DATABASE_RUNTIME_IMPORT__
-__JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__
-__JSKIT_CRUD_RESOURCE_NORMALIZE_SUPPORT_IMPORT__
-__JSKIT_CRUD_RESOURCE_JSON_IMPORT__
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 
-const RESOURCE_LOOKUP_CONTAINER_KEY = "lookups";
-
-const recordOutputSchema = Type.Object(
-  {
-__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__
-    [RESOURCE_LOOKUP_CONTAINER_KEY]: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
-  },
-  { additionalProperties: false }
-);
-
-const createBodySchema = Type.Object(
-  {
-__JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__
-  },
-  {
-    additionalProperties: false,
-    required: __JSKIT_CRUD_RESOURCE_CREATE_REQUIRED_FIELDS__
-  }
-);
-
-const patchBodySchema = Type.Partial(createBodySchema, {
-  additionalProperties: false
-});
-
-const recordOutputValidator = Object.freeze({
-  schema: recordOutputSchema,
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const normalized = {
-__JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__
-    };
-    if (Object.hasOwn(source, RESOURCE_LOOKUP_CONTAINER_KEY)) {
-      normalized[RESOURCE_LOOKUP_CONTAINER_KEY] = source[RESOURCE_LOOKUP_CONTAINER_KEY];
-    }
-
-    return normalized;
-  }
-});
-
-const listOutputValidator = createCursorListValidator(recordOutputValidator);
-
-const createBodyValidator = Object.freeze({
-  schema: createBodySchema,
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const normalized = {};
-
-__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__
-
-    return normalized;
-  }
-});
-
-const patchBodyValidator = Object.freeze({
-  schema: patchBodySchema,
-  normalize: createBodyValidator.normalize
-});
-
-const deleteOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      id: recordIdSchema,
-      deleted: Type.Literal(true)
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      id: normalizeRecordId(source.id, { fallback: "" }),
-      deleted: true
-    };
-  }
-});
-
-const RESOURCE_FIELD_META = [];
-
-const resource = {
+const resource = defineCrudResource({
   namespace: "${option:namespace|snake}",
   tableName: __JSKIT_CRUD_TABLE_NAME__,
-  idColumn: __JSKIT_CRUD_ID_COLUMN__,
+  schema: {
+__JSKIT_CRUD_RESOURCE_SCHEMA_PROPERTIES__
+  },
+  searchSchema: {
+__JSKIT_CRUD_RESOURCE_SEARCH_SCHEMA_LINES__
+  },
+  defaultSort: __JSKIT_CRUD_RESOURCE_DEFAULT_SORT__,
+  autofilter: __JSKIT_CRUD_RESOURCE_AUTOFILTER__,
   messages: {
     validation: "Fix invalid values and try again.",
     saveSuccess: "Record saved.",
@@ -95,61 +20,11 @@ const resource = {
   },
   contract: {
     lookup: {
-      containerKey: RESOURCE_LOOKUP_CONTAINER_KEY,
-      defaultInclude: "*", // Set "none" to disable lookup hydration unless include=... is passed.
-      maxDepth: 3 // Lower this to limit nested lookup hydration depth.
-    }
-  },
-  operations: {
-    list: {
-      realtime: {
-        events: ["${option:namespace|snake}.record.changed"] // Add more events e.g. for lookup records
-      },
-      method: "GET",
-      outputValidator: listOutputValidator
-    },
-    view: {
-      method: "GET",
-      outputValidator: recordOutputValidator
-    },
-    create: {
-      method: "POST",
-      bodyValidator: createBodyValidator,
-      outputValidator: recordOutputValidator
-    },
-    patch: {
-      method: "PATCH",
-      bodyValidator: patchBodyValidator,
-      outputValidator: recordOutputValidator
-    },
-    delete: {
-      method: "DELETE",
-      outputValidator: deleteOutputValidator
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
     }
-  },
-  fieldMeta: RESOURCE_FIELD_META
-};
+  }
+});
 
 export { resource };
-
-// @jskit-contract crud.resource.field-meta.${option:namespace|snake}.v1
-void RESOURCE_FIELD_META;
-
-// Example 1:n collection hydration:
-// RESOURCE_FIELD_META.push({
-//   key: "pets",
-//   relation: {
-//     kind: "collection",
-//     namespace: "pets",
-//     foreignKey: "customerId",
-//     parentValueKey: "id",
-//     hydrateOnList: false, // list: opt-in with include=pets
-//     hydrateOnView: true // view: hydrated by default
-//   }
-// });
-//
-// To hydrate child lookups too, request nested include paths:
-// - include=pets
-// - include=pets,pets.breedId
-
-__JSKIT_CRUD_RESOURCE_FIELD_META_PUSH_LINES__