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

package/src/shared/crud/crudResource.js

@@ -1,143 +1,90 @@
-import { Type } from "typebox";
-import {
-  toIsoString
-} from "@jskit-ai/database-runtime/shared";
-import {
-  normalizeObjectInput,
-  createCursorListValidator,
-  recordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
-import {
-  normalizeText,
-  normalizeRecordId,
-  normalizeFiniteNumber,
-  normalizeIfPresent
-} from "@jskit-ai/kernel/shared/support/normalize";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 
-const RESOURCE_LOOKUP_CONTAINER_KEY = "lookups";
-
-const recordOutputSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    textField: Type.String({ minLength: 1, maxLength: 160 }),
-    dateField: Type.String({ minLength: 1 }),
-    numberField: Type.Number(),
-    createdAt: Type.String({ minLength: 1 }),
-    updatedAt: Type.String({ minLength: 1 }),
-    [RESOURCE_LOOKUP_CONTAINER_KEY]: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
-  },
-  { additionalProperties: false }
-);
-
-const recordBodySchema = Type.Object(
-  {
-    textField: Type.String({
+const crudResource = defineCrudResource({
+  namespace: "crud",
+  tableName: "crud",
+  schema: {
+    textField: {
+      type: "string",
+      required: true,
       minLength: 1,
       maxLength: 160,
-      messages: {
-        required: "Text field is required.",
-        minLength: "Text field is required.",
-        maxLength: "Text field must be at most 160 characters.",
-        default: "Text field is required."
+      operations: {
+        output: { required: true },
+        create: {
+          required: true,
+          messages: {
+            required: "Text field is required.",
+            minLength: "Text field is required.",
+            maxLength: "Text field must be at most 160 characters.",
+            default: "Text field is required."
+          }
+        },
+        patch: {
+          required: false,
+          messages: {
+            minLength: "Text field is required.",
+            maxLength: "Text field must be at most 160 characters.",
+            default: "Text field is required."
+          }
+        }
       }
-    }),
-    dateField: Type.String({
-      minLength: 1,
-      messages: {
-        required: "Date field is required.",
-        minLength: "Date field is required.",
-        default: "Date field is required."
+    },
+    dateField: {
+      type: "dateTime",
+      required: true,
+      operations: {
+        output: { required: true },
+        create: {
+          required: true,
+          messages: {
+            required: "Date field is required.",
+            default: "Date field is required."
+          }
+        },
+        patch: {
+          required: false,
+          messages: {
+            default: "Date field is required."
+          }
+        }
       }
-    }),
-    numberField: Type.Number({
-      messages: {
-        required: "Number field is required.",
-        default: "Number field must be a valid number."
+    },
+    numberField: {
+      type: "number",
+      required: true,
+      operations: {
+        output: { required: true },
+        create: {
+          required: true,
+          messages: {
+            required: "Number field is required.",
+            default: "Number field must be a valid number."
+          }
+        },
+        patch: {
+          required: false,
+          messages: {
+            default: "Number field must be a valid number."
+          }
+        }
       }
-    })
-  },
-  {
-    additionalProperties: false,
-    messages: {
-      additionalProperties: "Unexpected field.",
-      default: "Invalid value."
-    }
-  }
-);
-
-const patchBodySchema = Type.Partial(recordBodySchema, { additionalProperties: false });
-
-const recordOutputValidator = Object.freeze({
-  schema: recordOutputSchema,
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const normalized = {
-      id: normalizeRecordId(source.id, { fallback: "" }),
-      textField: normalizeText(source.textField),
-      dateField: toIsoString(source.dateField),
-      numberField: normalizeFiniteNumber(source.numberField),
-      createdAt: normalizeIfPresent(source.createdAt, toIsoString),
-      updatedAt: normalizeIfPresent(source.updatedAt, toIsoString)
-    };
-    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: recordBodySchema,
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const normalized = {};
-
-    if (Object.hasOwn(source, "textField")) {
-      normalized.textField = normalizeText(source.textField);
-    }
-    if (Object.hasOwn(source, "dateField")) {
-      normalized.dateField = toIsoString(source.dateField);
-    }
-    if (Object.hasOwn(source, "numberField")) {
-      normalized.numberField = normalizeFiniteNumber(source.numberField);
-    }
-
-    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 CRUD_RESOURCE_FIELD_META = [];
-
-const crudResource = {
-  namespace: "crud",
-  tableName: "crud",
-  idColumn: "id",
+    createdAt: {
+      type: "dateTime",
+      required: true,
+      operations: {
+        output: { required: true }
+      }
+    },
+    updatedAt: {
+      type: "dateTime",
+      required: true,
+      operations: {
+        output: { required: true }
+      }
+    }
+  },
   messages: {
     validation: "Fix invalid CRUD values and try again.",
     saveSuccess: "Record saved.",
@@ -147,58 +94,11 @@ const crudResource = {
   },
   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.
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
     }
-  },
-  operations: {
-    list: {
-      realtime: {
-        events: ["crud.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
-    }
-  },
-  fieldMeta: CRUD_RESOURCE_FIELD_META
-};
-
-void CRUD_RESOURCE_FIELD_META;
-
-// Example 1:n collection hydration:
-// CRUD_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
+  }
+});
 
 export { crudResource };

package/templates/src/local-package/package.descriptor.mjs

@@ -9,8 +9,9 @@ export default Object.freeze({
     "@jskit-ai/crud-core",
     "@jskit-ai/database-runtime",
     "@jskit-ai/http-runtime",
+    "@jskit-ai/json-rest-api-core",
     "@jskit-ai/realtime",
-    "@jskit-ai/users-core"
+    "@jskit-ai/resource-crud-core",
   ],
   capabilities: {
     provides: [
@@ -20,7 +21,7 @@ export default Object.freeze({
       "runtime.actions",
       "runtime.database",
       "auth.policy",
-      "users.core"
+      "json-rest-api.core"
     ]
   },
   runtime: {
@@ -36,10 +37,6 @@ export default Object.freeze({
   metadata: {
     apiSummary: {
       surfaces: [
-        {
-          subpath: "./server/actionIds",
-          summary: "App-local CRUD public action identifiers."
-        },
         {
           subpath: "./shared",
           summary: "App-local CRUD shared resource."

package/templates/src/local-package/package.json

@@ -4,7 +4,6 @@
   "private": true,
   "type": "module",
   "exports": {
-    "./server/actionIds": "./src/server/actionIds.js",
     "./shared": "./src/shared/index.js"
   }
 }

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

@@ -1,23 +1,28 @@
 import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
 import { resolveCrudSurfacePolicyFromAppConfig } from "@jskit-ai/crud-core/server/crudModuleConfig";
+import { createCrudJsonApiServiceEvents } from "@jskit-ai/crud-core/server/serviceEvents";
 import {
-  createCrudLookupResolver,
-  createCrudLookup
-} from "@jskit-ai/crud-core/server/lookups";
+  INTERNAL_JSON_REST_API,
+  addResourceIfMissing,
+  createJsonRestResourceScopeOptions
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "./repository.js";
-import {
-  createService,
-  serviceEvents
-} from "./service.js";
+import { createService } from "./service.js";
 import { createActions } from "./actions.js";
 import { registerRoutes } from "./registerRoutes.js";
+import { resource } from "../shared/${option:namespace|singular|camel}Resource.js";
 const CRUD_MODULE_CONFIG = Object.freeze({
   namespace: "${option:namespace|snake}",
   surface: __JSKIT_CRUD_SURFACE_ID__,
   ownershipFilter: "__JSKIT_CRUD_RESOLVED_OWNERSHIP_FILTER__",
   relativePath: "/${option:directory-prefix|pathprefix}${option:namespace|kebab}"
 });
+const baseServiceEvents = createCrudJsonApiServiceEvents(CRUD_MODULE_CONFIG.namespace);
+const serviceEvents = {
+  ...baseServiceEvents
+};
 
 function resolveCrudPolicyFromApp(app) {
   return resolveCrudSurfacePolicyFromAppConfig(CRUD_MODULE_CONFIG, resolveAppConfig(app), {
@@ -28,25 +33,17 @@ function resolveCrudPolicyFromApp(app) {
 class ${option:namespace|pascal}Provider {
   static id = "crud.${option:namespace|snake}";
 
-  static dependsOn = ["runtime.actions", "runtime.database", "auth.policy.fastify", "local.main", "users.core"];
+  static dependsOn = ["runtime.actions", "runtime.database", "auth.policy.fastify", "local.main", "json-rest-api.core"];
 
   register(app) {
-    if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-      throw new Error("${option:namespace|pascal}Provider requires application singleton()/service()/actions().");
-    }
-
     const crudPolicy = resolveCrudPolicyFromApp(app);
 
     app.singleton("repository.${option:namespace|snake}", (scope) => {
+      const api = scope.make(INTERNAL_JSON_REST_API);
       const knex = scope.make("jskit.database.knex");
-      return createRepository(knex, {
-        resolveLookup: createCrudLookupResolver(scope)
-      });
-    });
-
-    app.singleton("lookup.${option:namespace|snake}", (scope) => {
-      return createCrudLookup(scope.make("repository.${option:namespace|snake}"), {
-        ownershipFilter: crudPolicy.ownershipFilter
+      return createRepository({
+        api,
+        knex
       });
     });
 
@@ -77,8 +74,18 @@ class ${option:namespace|pascal}Provider {
     );
   }
 
-  boot(app) {
+  async boot(app) {
     const crudPolicy = resolveCrudPolicyFromApp(app);
+    const api = app.make(INTERNAL_JSON_REST_API);
+    await addResourceIfMissing(
+      api,
+      __JSKIT_CRUD_JSONREST_SCOPE_NAME__,
+      createJsonRestResourceScopeOptions(resource, {
+        writeSerializers: {
+          "datetime-utc": toDatabaseDateTimeUtc
+        }
+      })
+    );
     registerRoutes(app, {
       routeOwnershipFilter: crudPolicy.ownershipFilter,
       routeSurface: crudPolicy.surfaceId,

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

@@ -1,4 +1,5 @@
 import {
+  composeSchemaDefinitions,
   recordIdParamsValidator
 } from "@jskit-ai/kernel/shared/validators";
 import {
@@ -8,130 +9,117 @@ import {
   createCrudParentFilterQueryValidator
 } from "@jskit-ai/crud-core/server/listQueryValidators";
 import { resource } from "../shared/${option:namespace|singular|camel}Resource.js";
-import { actionIds } from "./actionIds.js";
-import { LIST_CONFIG } from "./listConfig.js";
 __JSKIT_CRUD_ACTION_WORKSPACE_VALIDATOR_IMPORT__
 
-const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator(LIST_CONFIG);
+const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator({
+  orderBy: resource.defaultSort
+});
 const listParentFilterQueryValidator = createCrudParentFilterQueryValidator(resource);
 __JSKIT_CRUD_ACTION_PERMISSION_SUPPORT__
 
-function requireActionSurface(surface = "") {
-  const normalizedSurface = String(surface || "").trim().toLowerCase();
-  if (!normalizedSurface) {
-    throw new TypeError("createActions requires a non-empty surface.");
-  }
-
-  return normalizedSurface;
-}
-
-function createActions({ surface = "" } = {}) {
-  const actionSurface = requireActionSurface(surface);
-
+function createActions({ surface } = {}) {
   return Object.freeze([
     {
-      id: actionIds.list,
+      id: "crud.${option:namespace|snake}.list",
       version: 1,
       kind: "query",
       channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
+      surfaces: [surface],
       permission: __JSKIT_CRUD_LIST_ACTION_PERMISSION__,
-      inputValidator: __JSKIT_CRUD_LIST_ACTION_INPUT_VALIDATOR__,
-      outputValidator: resource.operations.list.outputValidator,
+      input: __JSKIT_CRUD_LIST_ACTION_INPUT__,
+      output: null,
       idempotency: "none",
       audit: {
-        actionName: actionIds.list
+        actionName: "crud.${option:namespace|snake}.list"
       },
       observability: {},
       async execute(input, context, deps) {
-        return deps.${option:namespace|camel}Service.listRecords(input, {
-          context,
-          visibilityContext: context?.visibilityContext
+        const { workspaceSlug, ...query } = input || {};
+        return deps.${option:namespace|camel}Service.queryDocuments(query, {
+          context
         });
       }
     },
     {
-      id: actionIds.view,
+      id: "crud.${option:namespace|snake}.view",
       version: 1,
       kind: "query",
       channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
+      surfaces: [surface],
       permission: __JSKIT_CRUD_VIEW_ACTION_PERMISSION__,
-      inputValidator: __JSKIT_CRUD_VIEW_ACTION_INPUT_VALIDATOR__,
-      outputValidator: resource.operations.view.outputValidator,
+      input: __JSKIT_CRUD_VIEW_ACTION_INPUT__,
+      output: null,
       idempotency: "none",
       audit: {
-        actionName: actionIds.view
+        actionName: "crud.${option:namespace|snake}.view"
       },
       observability: {},
       async execute(input, context, deps) {
-        return deps.${option:namespace|camel}Service.getRecord(input.recordId, {
+        return deps.${option:namespace|camel}Service.getDocumentById(input.recordId, {
           context,
-          visibilityContext: context?.visibilityContext,
           include: input.include
         });
       }
     },
     {
-      id: actionIds.create,
+      id: "crud.${option:namespace|snake}.create",
       version: 1,
       kind: "command",
       channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
+      surfaces: [surface],
       permission: __JSKIT_CRUD_CREATE_ACTION_PERMISSION__,
-      inputValidator: __JSKIT_CRUD_CREATE_ACTION_INPUT_VALIDATOR__,
-      outputValidator: resource.operations.create.outputValidator,
+      input: __JSKIT_CRUD_CREATE_ACTION_INPUT__,
+      output: null,
       idempotency: "optional",
       audit: {
-        actionName: actionIds.create
+        actionName: "crud.${option:namespace|snake}.create"
       },
       observability: {},
       async execute(input, context, deps) {
-        return deps.${option:namespace|camel}Service.createRecord(input.payload, {
-          context,
-          visibilityContext: context?.visibilityContext
+        const { workspaceSlug, ...payload } = input || {};
+        return deps.${option:namespace|camel}Service.createDocument(payload, {
+          context
         });
       }
     },
     {
-      id: actionIds.update,
+      id: "crud.${option:namespace|snake}.update",
       version: 1,
       kind: "command",
       channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
+      surfaces: [surface],
       permission: __JSKIT_CRUD_UPDATE_ACTION_PERMISSION__,
-      inputValidator: __JSKIT_CRUD_UPDATE_ACTION_INPUT_VALIDATOR__,
-      outputValidator: resource.operations.patch.outputValidator,
+      input: __JSKIT_CRUD_UPDATE_ACTION_INPUT__,
+      output: null,
       idempotency: "optional",
       audit: {
-        actionName: actionIds.update
+        actionName: "crud.${option:namespace|snake}.update"
       },
       observability: {},
       async execute(input, context, deps) {
-        return deps.${option:namespace|camel}Service.updateRecord(input.recordId, input.patch, {
-          context,
-          visibilityContext: context?.visibilityContext
+        const { workspaceSlug, recordId, ...patch } = input || {};
+        return deps.${option:namespace|camel}Service.patchDocumentById(recordId, patch, {
+          context
         });
       }
     },
     {
-      id: actionIds.delete,
+      id: "crud.${option:namespace|snake}.delete",
       version: 1,
       kind: "command",
       channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
+      surfaces: [surface],
       permission: __JSKIT_CRUD_DELETE_ACTION_PERMISSION__,
-      inputValidator: __JSKIT_CRUD_DELETE_ACTION_INPUT_VALIDATOR__,
-      outputValidator: resource.operations.delete.outputValidator,
+      input: __JSKIT_CRUD_DELETE_ACTION_INPUT__,
+      output: null,
       idempotency: "optional",
       audit: {
-        actionName: actionIds.delete
+        actionName: "crud.${option:namespace|snake}.delete"
       },
       observability: {},
       async execute(input, context, deps) {
-        return deps.${option:namespace|camel}Service.deleteRecord(input.recordId, {
-          context,
-          visibilityContext: context?.visibilityContext
+        return deps.${option:namespace|camel}Service.deleteDocumentById(input.recordId, {
+          context
         });
       }
     }