@jskit-ai/crud-server-generator 0.1.26 → 0.1.28

package/test/routeInputContracts.test.js

@@ -1,7 +1,14 @@
 import assert from "node:assert/strict";
-import test from "node:test";
-import { registerRoutes } from "../src/server/registerRoutes.js";
+import test, { after } from "node:test";
 import { resolveApiBasePath } from "@jskit-ai/users-core/shared/support/usersApiPaths";
+import { createTemplateServerFixture } from "../test-support/templateServerFixture.js";
+
+const fixture = await createTemplateServerFixture();
+const { registerRoutes } = await fixture.importServerModule("registerRoutes.js");
+
+after(async () => {
+  await fixture.cleanup();
+});
 
 function createReplyDouble() {
   return {
@@ -45,14 +52,7 @@ test("crud routes build create/update action input with explicit payload and pat
 
   registerRoutes(app, {
     routeRelativePath: "/customers",
-    routeSurfaceRequiresWorkspace: true,
-    actionIds: {
-      list: "crud.customers.list",
-      view: "crud.customers.view",
-      create: "crud.customers.create",
-      update: "crud.customers.update",
-      delete: "crud.customers.delete"
-    }
+    routeSurfaceRequiresWorkspace: true
   });
 
   const workspaceRouteBase = resolveApiBasePath({
@@ -125,14 +125,7 @@ test("crud routes omit workspaceSlug for non-workspace calls and apply configure
 
   registerRoutes(app, {
     routeRelativePath: "/customers",
-    routeSurface: "console",
-    actionIds: {
-      list: "crud.customers.list",
-      view: "crud.customers.view",
-      create: "crud.customers.create",
-      update: "crud.customers.update",
-      delete: "crud.customers.delete"
-    }
+    routeSurface: "console"
   });
 
   const createRoute = findRoute(registeredRoutes, "POST", "/api/customers");
@@ -161,7 +154,7 @@ test("crud routes omit workspaceSlug for non-workspace calls and apply configure
   });
 });
 
-test("crud routes normalize route ownership filter values before registering visibility", () => {
+test("crud routes validate route ownership filter values before registering visibility", () => {
   const registeredRoutes = [];
   const router = {
     register(method, path, route, handler) {
@@ -184,32 +177,142 @@ test("crud routes normalize route ownership filter values before registering vis
 
   registerRoutes(app, {
     routeRelativePath: "/customers",
-    routeOwnershipFilter: " Workspace_User ",
-    actionIds: {
-      list: "crud.customers.list",
-      view: "crud.customers.view",
-      create: "crud.customers.create",
-      update: "crud.customers.update",
-      delete: "crud.customers.delete"
-    }
-  });
-  registerRoutes(app, {
-    routeRelativePath: "/customers-public",
-    routeOwnershipFilter: "not-a-real-filter",
-    actionIds: {
-      list: "crud.customers-public.list",
-      view: "crud.customers-public.view",
-      create: "crud.customers-public.create",
-      update: "crud.customers-public.update",
-      delete: "crud.customers-public.delete"
-    }
+    routeOwnershipFilter: " Workspace_User "
   });
+  assert.throws(
+    () =>
+      registerRoutes(app, {
+        routeRelativePath: "/customers-public",
+        routeOwnershipFilter: "not-a-real-filter"
+      }),
+    /must be one of/
+  );
 
   const workspaceUserRoute = findRoute(registeredRoutes, "GET", "/api/customers");
-  const fallbackPublicRoute = findRoute(registeredRoutes, "GET", "/api/customers-public");
 
   assert.ok(workspaceUserRoute);
-  assert.ok(fallbackPublicRoute);
   assert.equal(workspaceUserRoute.route.visibility, "workspace_user");
-  assert.equal(fallbackPublicRoute.route.visibility, "public");
+});
+
+test("crud list route forwards normalized query input from list query validators", async () => {
+  const registeredRoutes = [];
+  const router = {
+    register(method, path, route, handler) {
+      registeredRoutes.push({
+        method,
+        path,
+        route,
+        handler
+      });
+    }
+  };
+  const app = {
+    make(token) {
+      if (token !== "jskit.http.router") {
+        throw new Error(`Unexpected token: ${String(token)}`);
+      }
+      return router;
+    }
+  };
+
+  registerRoutes(app, {
+    routeRelativePath: "/customers",
+    routeSurfaceRequiresWorkspace: true
+  });
+
+  const workspaceRouteBase = resolveApiBasePath({
+    surfaceRequiresWorkspace: true,
+    relativePath: "/customers"
+  });
+  const listRoute = findRoute(registeredRoutes, "GET", workspaceRouteBase);
+  assert.ok(listRoute);
+
+  const calls = [];
+  const executeAction = async (payload) => {
+    calls.push(payload);
+    return {};
+  };
+
+  await listRoute.handler(
+    {
+      input: {
+        params: { workspaceSlug: "acme" },
+        query: {
+          cursor: 3,
+          limit: 25,
+          q: "to",
+          contactId: "2971",
+          include: "vetId"
+        }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+
+  assert.deepEqual(calls[0].input, {
+    workspaceSlug: "acme",
+    cursor: 3,
+    limit: 25,
+    q: "to",
+    contactId: "2971",
+    include: "vetId"
+  });
+});
+
+test("crud view route forwards include query input", async () => {
+  const registeredRoutes = [];
+  const router = {
+    register(method, path, route, handler) {
+      registeredRoutes.push({
+        method,
+        path,
+        route,
+        handler
+      });
+    }
+  };
+  const app = {
+    make(token) {
+      if (token !== "jskit.http.router") {
+        throw new Error(`Unexpected token: ${String(token)}`);
+      }
+      return router;
+    }
+  };
+
+  registerRoutes(app, {
+    routeRelativePath: "/customers",
+    routeSurfaceRequiresWorkspace: true
+  });
+
+  const workspaceRouteBase = resolveApiBasePath({
+    surfaceRequiresWorkspace: true,
+    relativePath: "/customers"
+  });
+  const viewRoute = findRoute(registeredRoutes, "GET", `${workspaceRouteBase}/:recordId`);
+  assert.ok(viewRoute);
+
+  const calls = [];
+  const executeAction = async (payload) => {
+    calls.push(payload);
+    return {};
+  };
+
+  await viewRoute.handler(
+    {
+      input: {
+        params: { workspaceSlug: "acme", recordId: 7 },
+        query: { include: "vetId" }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+
+  assert.deepEqual(calls[0].input, {
+    workspaceSlug: "acme",
+    recordId: 7,
+    include: "vetId"
+  });
 });

package/test-support/templateServerFixture.js

@@ -0,0 +1,169 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const testSupportDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(testSupportDirectory, "..");
+const serverTemplateRoot = path.join(packageRoot, "templates", "src", "local-package", "server");
+
+const CRUD_NAMESPACE = Object.freeze({
+  snake: "customers",
+  camel: "customers",
+  singularCamel: "customer",
+  pascal: "Customers"
+});
+
+const TEMPLATE_REPLACEMENTS = Object.freeze([
+  ["${option:namespace|snake}", CRUD_NAMESPACE.snake],
+  ["${option:namespace|camel}", CRUD_NAMESPACE.camel],
+  ["${option:namespace|singular|camel}", CRUD_NAMESPACE.singularCamel],
+  ["${option:namespace|pascal}", CRUD_NAMESPACE.pascal],
+  ["__JSKIT_CRUD_ID_COLUMN__", JSON.stringify("id")]
+]);
+
+function applyTemplateReplacements(sourceText = "") {
+  let rendered = String(sourceText || "");
+  for (const [needle, replacement] of TEMPLATE_REPLACEMENTS) {
+    rendered = rendered.split(needle).join(replacement);
+  }
+  return rendered;
+}
+
+function buildResourceStubSource() {
+  return `const recordOutputValidator = Object.freeze({
+  schema: {
+    properties: {
+      id: {},
+      name: {}
+    }
+  },
+  normalize(payload = {}) {
+    return payload;
+  }
+});
+
+const createBodyValidator = Object.freeze({
+  schema: {
+    properties: {
+      name: {},
+      contactId: {}
+    }
+  },
+  normalize(payload = {}) {
+    return payload;
+  }
+});
+
+const patchBodyValidator = Object.freeze({
+  schema: {
+    properties: {
+      name: {},
+      contactId: {}
+    }
+  },
+  normalize: createBodyValidator.normalize
+});
+
+const resource = Object.freeze({
+  resource: "customers",
+  tableName: "customers",
+  idColumn: "id",
+  operations: {
+    list: {
+      outputValidator: Object.freeze({
+        schema: {
+          properties: {
+            items: {},
+            nextCursor: {}
+          }
+        },
+        normalize(payload = {}) {
+          return payload;
+        }
+      })
+    },
+    view: {
+      outputValidator: recordOutputValidator
+    },
+    create: {
+      bodyValidator: createBodyValidator,
+      outputValidator: recordOutputValidator
+    },
+    patch: {
+      bodyValidator: patchBodyValidator,
+      outputValidator: recordOutputValidator
+    },
+    delete: {
+      outputValidator: Object.freeze({
+        schema: {
+          properties: {
+            id: {},
+            deleted: {}
+          }
+        },
+        normalize(payload = {}) {
+          return payload;
+        }
+      })
+    }
+  },
+  fieldMeta: [
+    {
+      key: "contactId",
+      relation: {
+        kind: "lookup",
+        namespace: "contacts",
+        valueKey: "id"
+      }
+    }
+  ]
+});
+
+export { resource };
+`;
+}
+
+async function renderServerTemplateFile(targetServerDirectory, fileName) {
+  const templatePath = path.join(serverTemplateRoot, fileName);
+  const templateSource = await readFile(templatePath, "utf8");
+  const renderedSource = applyTemplateReplacements(templateSource);
+  await writeFile(path.join(targetServerDirectory, fileName), renderedSource, "utf8");
+}
+
+async function createTemplateServerFixture() {
+  const fixtureRoot = await mkdtemp(path.join(packageRoot, ".tmp-crud-server-template-fixture-"));
+  const srcRoot = path.join(fixtureRoot, "src");
+  const serverRoot = path.join(srcRoot, "server");
+  const sharedRoot = path.join(srcRoot, "shared");
+
+  await mkdir(serverRoot, { recursive: true });
+  await mkdir(sharedRoot, { recursive: true });
+  await writeFile(
+    path.join(fixtureRoot, "package.json"),
+    JSON.stringify({ name: "crud-server-template-fixture", private: true, type: "module" }, null, 2),
+    "utf8"
+  );
+  await writeFile(path.join(sharedRoot, "customerResource.js"), buildResourceStubSource(), "utf8");
+
+  for (const fileName of ["actionIds.js", "actions.js", "registerRoutes.js", "repository.js", "service.js"]) {
+    await renderServerTemplateFile(serverRoot, fileName);
+  }
+
+  async function importServerModule(fileName) {
+    const absolutePath = path.join(serverRoot, fileName);
+    const href = pathToFileURL(absolutePath).href;
+    return import(`${href}?t=${Date.now()}_${Math.random()}`);
+  }
+
+  async function cleanup() {
+    await rm(fixtureRoot, { recursive: true, force: true });
+  }
+
+  return Object.freeze({
+    fixtureRoot,
+    importServerModule,
+    cleanup
+  });
+}
+
+export { createTemplateServerFixture };

package/src/server/actionIds.js

@@ -1,22 +0,0 @@
-function requireActionIdPrefix(actionIdPrefix) {
-  const prefix = String(actionIdPrefix || "").trim();
-  if (!prefix) {
-    throw new TypeError("createActionIds requires actionIdPrefix.");
-  }
-
-  return prefix;
-}
-
-function createActionIds(actionIdPrefix) {
-  const prefix = requireActionIdPrefix(actionIdPrefix);
-
-  return Object.freeze({
-    list: `${prefix}.list`,
-    view: `${prefix}.view`,
-    create: `${prefix}.create`,
-    update: `${prefix}.update`,
-    delete: `${prefix}.delete`
-  });
-}
-
-export { requireActionIdPrefix, createActionIds };

package/src/server/actions.js

@@ -1,152 +0,0 @@
-import {
-  cursorPaginationQueryValidator,
-  recordIdParamsValidator
-} from "@jskit-ai/kernel/shared/validators";
-import { workspaceSlugParamsValidator } from "@jskit-ai/users-core/server/validators/routeParamsValidator";
-import { crudResource } from "../shared/crud/crudResource.js";
-import { createActionIds } from "./actionIds.js";
-
-function requireActionSurface(surface = "") {
-  const normalizedSurface = String(surface || "").trim().toLowerCase();
-  if (!normalizedSurface) {
-    throw new TypeError("createActions requires a non-empty surface.");
-  }
-
-  return normalizedSurface;
-}
-
-function createActions({ actionIdPrefix, surface = "" } = {}) {
-  const actionIds = createActionIds(actionIdPrefix);
-  const actionSurface = requireActionSurface(surface);
-
-  return Object.freeze([
-    {
-      id: actionIds.list,
-      version: 1,
-      kind: "query",
-      channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
-      permission: {
-        require: "authenticated"
-      },
-      inputValidator: [workspaceSlugParamsValidator, cursorPaginationQueryValidator],
-      outputValidator: crudResource.operations.list.outputValidator,
-      idempotency: "none",
-      audit: {
-        actionName: actionIds.list
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        return deps.crudService.listRecords(input, {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    },
-    {
-      id: actionIds.view,
-      version: 1,
-      kind: "query",
-      channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
-      permission: {
-        require: "authenticated"
-      },
-      inputValidator: [workspaceSlugParamsValidator, recordIdParamsValidator],
-      outputValidator: crudResource.operations.view.outputValidator,
-      idempotency: "none",
-      audit: {
-        actionName: actionIds.view
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        return deps.crudService.getRecord(input.recordId, {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    },
-    {
-      id: actionIds.create,
-      version: 1,
-      kind: "command",
-      channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
-      permission: {
-        require: "authenticated"
-      },
-      inputValidator: [
-        workspaceSlugParamsValidator,
-        {
-          payload: crudResource.operations.create.bodyValidator
-        }
-      ],
-      outputValidator: crudResource.operations.create.outputValidator,
-      idempotency: "optional",
-      audit: {
-        actionName: actionIds.create
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        return deps.crudService.createRecord(input.payload, {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    },
-    {
-      id: actionIds.update,
-      version: 1,
-      kind: "command",
-      channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
-      permission: {
-        require: "authenticated"
-      },
-      inputValidator: [
-        workspaceSlugParamsValidator,
-        recordIdParamsValidator,
-        {
-          patch: crudResource.operations.patch.bodyValidator
-        }
-      ],
-      outputValidator: crudResource.operations.patch.outputValidator,
-      idempotency: "optional",
-      audit: {
-        actionName: actionIds.update
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        return deps.crudService.updateRecord(input.recordId, input.patch, {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    },
-    {
-      id: actionIds.delete,
-      version: 1,
-      kind: "command",
-      channels: ["api", "automation", "internal"],
-      surfaces: [actionSurface],
-      permission: {
-        require: "authenticated"
-      },
-      inputValidator: [workspaceSlugParamsValidator, recordIdParamsValidator],
-      outputValidator: crudResource.operations.delete.outputValidator,
-      idempotency: "optional",
-      audit: {
-        actionName: actionIds.delete
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        return deps.crudService.deleteRecord(input.recordId, {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    }
-  ]);
-}
-
-export { createActions };