@jskit-ai/crud-server-generator 0.1.26

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

@@ -0,0 +1,96 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+
+const serviceEvents = Object.freeze({
+  createRecord: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "crud",
+      entity: "record",
+      operation: "created",
+      entityId: ({ result }) => result?.id,
+      realtime: Object.freeze({
+        event: "${option:namespace|snake}.record.changed",
+        audience: "event_scope"
+      })
+    })
+  ]),
+  updateRecord: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "crud",
+      entity: "record",
+      operation: "updated",
+      entityId: ({ result }) => result?.id,
+      realtime: Object.freeze({
+        event: "${option:namespace|snake}.record.changed",
+        audience: "event_scope"
+      })
+    })
+  ]),
+  deleteRecord: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "crud",
+      entity: "record",
+      operation: "deleted",
+      entityId: ({ result }) => result?.id,
+      realtime: Object.freeze({
+        event: "${option:namespace|snake}.record.changed",
+        audience: "event_scope"
+      })
+    })
+  ])
+});
+
+function createService({ ${option:namespace|camel}Repository } = {}) {
+  if (!${option:namespace|camel}Repository) {
+    throw new Error("${option:namespace|camel}Service requires ${option:namespace|camel}Repository.");
+  }
+
+  async function listRecords(query = {}, options = {}) {
+    return ${option:namespace|camel}Repository.list(query, options);
+  }
+
+  async function getRecord(recordId, options = {}) {
+    const record = await ${option:namespace|camel}Repository.findById(recordId, options);
+    if (!record) {
+      throw new AppError(404, "Record not found.");
+    }
+
+    return record;
+  }
+
+  async function createRecord(payload = {}, options = {}) {
+    const record = await ${option:namespace|camel}Repository.create(payload, options);
+    if (!record) {
+      throw new Error("${option:namespace|camel}Service could not load the created record.");
+    }
+    return record;
+  }
+
+  async function updateRecord(recordId, payload = {}, options = {}) {
+    const record = await ${option:namespace|camel}Repository.updateById(recordId, payload, options);
+    if (!record) {
+      throw new AppError(404, "Record not found.");
+    }
+    return record;
+  }
+
+  async function deleteRecord(recordId, options = {}) {
+    const deleted = await ${option:namespace|camel}Repository.deleteById(recordId, options);
+    if (!deleted) {
+      throw new AppError(404, "Record not found.");
+    }
+    return deleted;
+  }
+
+  return Object.freeze({
+    listRecords,
+    getRecord,
+    createRecord,
+    updateRecord,
+    deleteRecord
+  });
+}
+
+export { createService, serviceEvents };

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

@@ -0,0 +1,109 @@
+import { Type } from "typebox";
+__JSKIT_CRUD_RESOURCE_DATABASE_RUNTIME_IMPORT__
+import {
+  normalizeObjectInput,
+  createCursorListValidator
+} from "@jskit-ai/kernel/shared/validators";
+__JSKIT_CRUD_RESOURCE_NORMALIZE_SUPPORT_IMPORT__
+__JSKIT_CRUD_RESOURCE_JSON_IMPORT__
+function normalizeRecordInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__
+
+  return normalized;
+}
+
+function normalizeRecordOutput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+__JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__
+  };
+}
+
+const recordOutputSchema = Type.Object(
+  {
+__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__
+  },
+  { 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: normalizeRecordOutput
+});
+
+const ${option:namespace|singular|camel}Resource = {
+  resource: "${option:namespace|snake}",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  operations: {
+    list: {
+      method: "GET",
+      outputValidator: createCursorListValidator(recordOutputValidator)
+    },
+    view: {
+      method: "GET",
+      outputValidator: recordOutputValidator
+    },
+    create: {
+      method: "POST",
+      bodyValidator: {
+        schema: createBodySchema,
+        normalize: normalizeRecordInput
+      },
+      outputValidator: recordOutputValidator
+    },
+    patch: {
+      method: "PATCH",
+      bodyValidator: {
+        schema: patchBodySchema,
+        normalize: normalizeRecordInput
+      },
+      outputValidator: recordOutputValidator
+    },
+    delete: {
+      method: "DELETE",
+      outputValidator: {
+        schema: Type.Object(
+          {
+            id: Type.Integer({ minimum: 1 }),
+            deleted: Type.Literal(true)
+          },
+          { additionalProperties: false }
+        ),
+        normalize(payload = {}) {
+          const source = normalizeObjectInput(payload);
+
+          return {
+            id: Number(source.id),
+            deleted: true
+          };
+        }
+      }
+    }
+  }
+};
+
+export { ${option:namespace|singular|camel}Resource };

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

@@ -0,0 +1,3 @@
+export {
+  ${option:namespace|singular|camel}Resource
+} from "./${option:namespace|singular|camel}Resource.js";

package/test/buildTemplateContext.test.js

@@ -0,0 +1,256 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildTemplateContext, __testables } from "../src/server/buildTemplateContext.js";
+
+function createSnapshot({
+  tableName = "contacts",
+  hasWorkspaceOwnerColumn = true,
+  hasUserOwnerColumn = true
+} = {}) {
+  return Object.freeze({
+    tableName,
+    idColumn: "id",
+    primaryKeyColumns: Object.freeze(["id"]),
+    hasWorkspaceOwnerColumn,
+    hasUserOwnerColumn,
+    columns: Object.freeze([
+      Object.freeze({
+        name: "id",
+        key: "id",
+        dataType: "int",
+        columnType: "int unsigned",
+        typeKind: "integer",
+        nullable: false,
+        hasDefault: false,
+        defaultValue: null,
+        autoIncrement: true,
+        unsigned: true,
+        extra: "",
+        maxLength: null,
+        numericPrecision: 10,
+        numericScale: 0,
+        enumValues: Object.freeze([])
+      }),
+      Object.freeze({
+        name: "workspace_owner_id",
+        key: "workspaceOwnerId",
+        dataType: "int",
+        columnType: "int unsigned",
+        typeKind: "integer",
+        nullable: true,
+        hasDefault: false,
+        defaultValue: null,
+        autoIncrement: false,
+        unsigned: true,
+        extra: "",
+        maxLength: null,
+        numericPrecision: 10,
+        numericScale: 0,
+        enumValues: Object.freeze([])
+      }),
+      Object.freeze({
+        name: "user_owner_id",
+        key: "userOwnerId",
+        dataType: "int",
+        columnType: "int unsigned",
+        typeKind: "integer",
+        nullable: true,
+        hasDefault: false,
+        defaultValue: null,
+        autoIncrement: false,
+        unsigned: true,
+        extra: "",
+        maxLength: null,
+        numericPrecision: 10,
+        numericScale: 0,
+        enumValues: Object.freeze([])
+      }),
+      Object.freeze({
+        name: "first_name",
+        key: "firstName",
+        dataType: "varchar",
+        columnType: "varchar(160)",
+        typeKind: "string",
+        nullable: false,
+        hasDefault: false,
+        defaultValue: null,
+        autoIncrement: false,
+        unsigned: false,
+        extra: "",
+        maxLength: 160,
+        numericPrecision: null,
+        numericScale: null,
+        enumValues: Object.freeze([])
+      }),
+      Object.freeze({
+        name: "updated_at",
+        key: "updatedAt",
+        dataType: "datetime",
+        columnType: "datetime",
+        typeKind: "datetime",
+        nullable: false,
+        hasDefault: true,
+        defaultValue: "CURRENT_TIMESTAMP",
+        autoIncrement: false,
+        unsigned: false,
+        extra: "on update current_timestamp",
+        maxLength: null,
+        numericPrecision: null,
+        numericScale: null,
+        enumValues: Object.freeze([])
+      })
+    ]),
+    indexes: Object.freeze([])
+  });
+}
+
+test("resolveOwnershipFilterForGeneration infers ownership filter for table introspection mode", () => {
+  const snapshotBoth = createSnapshot({
+    hasWorkspaceOwnerColumn: true,
+    hasUserOwnerColumn: true
+  });
+  const snapshotWorkspaceOnly = createSnapshot({
+    hasWorkspaceOwnerColumn: true,
+    hasUserOwnerColumn: false
+  });
+  const snapshotUserOnly = createSnapshot({
+    hasWorkspaceOwnerColumn: false,
+    hasUserOwnerColumn: true
+  });
+  const snapshotPublic = createSnapshot({
+    hasWorkspaceOwnerColumn: false,
+    hasUserOwnerColumn: false
+  });
+
+  assert.equal(
+    __testables.resolveOwnershipFilterForGeneration(snapshotBoth, "auto", {
+      enforceTableColumns: true
+    }),
+    "workspace_user"
+  );
+  assert.equal(
+    __testables.resolveOwnershipFilterForGeneration(snapshotWorkspaceOnly, "auto", {
+      enforceTableColumns: true
+    }),
+    "workspace"
+  );
+  assert.equal(
+    __testables.resolveOwnershipFilterForGeneration(snapshotUserOnly, "auto", {
+      enforceTableColumns: true
+    }),
+    "user"
+  );
+  assert.equal(
+    __testables.resolveOwnershipFilterForGeneration(snapshotPublic, "auto", {
+      enforceTableColumns: true
+    }),
+    "public"
+  );
+});
+
+test("resolveOwnershipFilterForGeneration rejects explicit ownership filters when required columns are missing", () => {
+  const snapshotPublic = createSnapshot({
+    hasWorkspaceOwnerColumn: false,
+    hasUserOwnerColumn: false
+  });
+
+  assert.throws(
+    () =>
+      __testables.resolveOwnershipFilterForGeneration(snapshotPublic, "workspace", {
+        enforceTableColumns: true
+      }),
+    /requires column "workspace_owner_id"/
+  );
+  assert.throws(
+    () =>
+      __testables.resolveOwnershipFilterForGeneration(snapshotPublic, "user", {
+        enforceTableColumns: true
+      }),
+    /requires column "user_owner_id"/
+  );
+});
+
+test("buildTemplateContext requires table-name", async () => {
+  await assert.rejects(
+    buildTemplateContext({
+      appRoot: process.cwd(),
+      options: {
+        namespace: "contacts"
+      }
+    }),
+    /requires option "table-name"/
+  );
+});
+
+test("buildReplacementsFromSnapshot builds deterministic template replacement payload", () => {
+  const snapshot = createSnapshot();
+  const replacements = __testables.buildReplacementsFromSnapshot({
+    namespace: "contacts",
+    snapshot,
+    resolvedOwnershipFilter: "workspace_user"
+  });
+
+  assert.equal(replacements.__JSKIT_CRUD_TABLE_NAME__, "\"contacts\"");
+  assert.equal(replacements.__JSKIT_CRUD_ID_COLUMN__, "\"id\"");
+  assert.equal(replacements.__JSKIT_CRUD_RESOLVED_OWNERSHIP_FILTER__, "workspace_user");
+  assert.match(replacements.__JSKIT_CRUD_MIGRATION_COLUMN_LINES__, /table\.increments\("id"\)/);
+  assert.match(replacements.__JSKIT_CRUD_MIGRATION_COLUMN_LINES__, /table\.string\("first_name", 160\)/);
+  assert.match(replacements.__JSKIT_CRUD_REPOSITORY_OUTPUT_KEYS__, /"firstName"/);
+  assert.match(replacements.__JSKIT_CRUD_REPOSITORY_WRITE_KEYS__, /"firstName"/);
+  assert.equal(replacements.__JSKIT_CRUD_REPOSITORY_COLUMN_OVERRIDES__, "{}");
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__, /updatedAt: Type\.String/);
+  assert.match(
+    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_SCHEMA_PROPERTIES__,
+    /id: Type\.Integer\(\{ minimum: 1 \}\),/
+  );
+  assert.match(replacements.__JSKIT_CRUD_RESOURCE_CREATE_SCHEMA_PROPERTIES__, /firstName: Type\.String/);
+  assert.match(
+    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
+    /normalizeIfInSource\(source, normalized, "firstName", normalizeText\);/
+  );
+  assert.doesNotMatch(
+    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
+    /\(value\) =>/
+  );
+  assert.doesNotMatch(
+    replacements.__JSKIT_CRUD_RESOURCE_INPUT_NORMALIZATION_LINES__,
+    /value == null/
+  );
+  assert.match(
+    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__,
+    /firstName: normalizeIfPresent\(source\.firstName, normalizeText\),/
+  );
+  assert.doesNotMatch(
+    replacements.__JSKIT_CRUD_RESOURCE_OUTPUT_NORMALIZATION_LINES__,
+    /== null \?/
+  );
+  assert.equal(replacements.__JSKIT_CRUD_RESOURCE_CREATE_REQUIRED_FIELDS__, "[\"firstName\"]");
+});
+
+test("renderMigrationColumnLine ignores SQL NULL string defaults", () => {
+  const line = __testables.renderMigrationColumnLine(
+    {
+      name: "workspace_owner_id",
+      dataType: "int",
+      columnType: "int unsigned",
+      typeKind: "integer",
+      nullable: true,
+      hasDefault: true,
+      defaultValue: "NULL",
+      autoIncrement: false,
+      unsigned: true,
+      extra: "",
+      maxLength: null,
+      numericPrecision: 10,
+      numericScale: 0,
+      enumValues: []
+    },
+    {
+      idColumn: "id",
+      primaryKeyColumns: ["id"]
+    }
+  );
+
+  assert.equal(line.includes(".defaultTo("), false);
+});

package/test/crudModuleConfig.test.js

@@ -0,0 +1,225 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  resolveCrudConfig,
+  resolveCrudSurfacePolicy,
+  resolveCrudConfigFromModules,
+  resolveCrudConfigsFromModules
+} from "../src/server/crudModuleConfig.js";
+
+test("resolveCrudConfig throws when namespace is missing", () => {
+  assert.throws(
+    () => resolveCrudConfig({}),
+    /requires a non-empty namespace/
+  );
+});
+
+test("resolveCrudConfig normalizes namespaced public settings", () => {
+  const config = resolveCrudConfig({
+    namespace: "CRM Team",
+    ownershipFilter: "public"
+  });
+
+  assert.equal(config.namespace, "crm-team");
+  assert.equal(config.ownershipFilter, "public");
+  assert.equal(config.workspaceScoped, false);
+  assert.equal(config.namespacePath, "/crm-team");
+  assert.equal(config.relativePath, "/crm-team");
+  assert.equal(config.apiBasePath, "/api/crm-team");
+  assert.equal(config.tableName, "crud_crm_team");
+  assert.equal(config.actionIdPrefix, "crud.crm_team");
+  assert.equal(config.contributorId, "crud.crm_team");
+  assert.equal(config.domain, "crud");
+});
+
+test("resolveCrudConfigsFromModules returns only crud module entries", () => {
+  const configs = resolveCrudConfigsFromModules({
+    "crud.customers": {
+      module: "crud",
+      namespace: "customers",
+      ownershipFilter: "workspace"
+    },
+    "crud.dragons": {
+      module: "crud",
+      namespace: "dragons",
+      ownershipFilter: "public"
+    },
+    "users.default": {
+      module: "users",
+      namespace: "ignored"
+    }
+  });
+
+  assert.deepEqual(configs.map((entry) => entry.namespace), ["customers", "dragons"]);
+  assert.deepEqual(configs.map((entry) => entry.ownershipFilter), ["workspace", "public"]);
+});
+
+test("resolveCrudConfigFromModules resolves explicit namespace", () => {
+  const config = resolveCrudConfigFromModules(
+    {
+      "crud.customers": {
+        module: "crud",
+        namespace: "customers",
+        ownershipFilter: "workspace"
+      },
+      "crud.dragons": {
+        module: "crud",
+        namespace: "dragons",
+        ownershipFilter: "workspace_user"
+      }
+    },
+    {
+      namespace: "dragons"
+    }
+  );
+
+  assert.ok(config);
+  assert.equal(config.namespace, "dragons");
+  assert.equal(config.ownershipFilter, "workspace_user");
+});
+
+test("resolveCrudConfigFromModules returns null without namespace when multiple crud entries exist", () => {
+  const config = resolveCrudConfigFromModules({
+    "crud.customers": {
+      module: "crud",
+      namespace: "customers",
+      ownershipFilter: "workspace"
+    },
+    "crud.dragons": {
+      module: "crud",
+      namespace: "dragons",
+      ownershipFilter: "workspace"
+    }
+  });
+
+  assert.equal(config, null);
+});
+
+test("resolveCrudConfigsFromModules rejects duplicate normalized namespaces", () => {
+  assert.throws(
+    () =>
+      resolveCrudConfigsFromModules({
+        "crud.customers": {
+          module: "crud",
+          namespace: "customers",
+          ownershipFilter: "workspace"
+        },
+        "crud.customers-copy": {
+          module: "crud",
+          namespace: "Customers",
+          ownershipFilter: "public"
+        }
+      }),
+    /Duplicate CRUD namespace/
+  );
+});
+
+test("resolveCrudConfigsFromModules rejects module entries without namespace", () => {
+  assert.throws(
+    () =>
+      resolveCrudConfigsFromModules({
+        "crud.invalid": {
+          module: "crud",
+          namespace: "",
+          ownershipFilter: "workspace"
+        }
+      }),
+    /requires a non-empty namespace/
+  );
+});
+
+test("resolveCrudSurfacePolicy resolves auto ownership filter from workspace surface metadata", () => {
+  const policy = resolveCrudSurfacePolicy(
+    {
+      surface: "admin",
+      ownershipFilter: "auto",
+      relativePath: "/crm/customers"
+    },
+    {
+      surfaceDefinitions: {
+        admin: { requiresWorkspace: true, requiresAuth: true, enabled: true }
+      },
+      defaultSurfaceId: "admin"
+    }
+  );
+
+  assert.equal(policy.surfaceId, "admin");
+  assert.equal(policy.ownershipFilter, "workspace");
+  assert.equal(policy.workspaceScoped, true);
+  assert.equal(policy.relativePath, "/crm/customers");
+});
+
+test("resolveCrudSurfacePolicy resolves auto ownership filter from auth-only surface metadata", () => {
+  const policy = resolveCrudSurfacePolicy(
+    {
+      surface: "console",
+      ownershipFilter: "auto",
+      relativePath: "/crm/customers"
+    },
+    {
+      surfaceDefinitions: {
+        console: { requiresWorkspace: false, requiresAuth: true, enabled: true }
+      },
+      defaultSurfaceId: "console"
+    }
+  );
+
+  assert.equal(policy.surfaceId, "console");
+  assert.equal(policy.ownershipFilter, "user");
+  assert.equal(policy.workspaceScoped, false);
+});
+
+test("resolveCrudSurfacePolicy rejects explicit workspace ownership filter on non-workspace surfaces", () => {
+  assert.throws(
+    () =>
+      resolveCrudSurfacePolicy(
+        {
+          surface: "console",
+          ownershipFilter: "workspace",
+          relativePath: "/crm/customers"
+        },
+        {
+          surfaceDefinitions: {
+            console: { requiresWorkspace: false, requiresAuth: true, enabled: true }
+          }
+        }
+      ),
+    /requires a workspace-enabled surface/
+  );
+});
+
+test("resolveCrudSurfacePolicy rejects unknown or disabled surfaces", () => {
+  assert.throws(
+    () =>
+      resolveCrudSurfacePolicy(
+        {
+          surface: "missing",
+          ownershipFilter: "auto",
+          relativePath: "/crm/customers"
+        },
+        {
+          surfaceDefinitions: {
+            console: { requiresWorkspace: false, requiresAuth: true, enabled: true }
+          }
+        }
+      ),
+    /cannot resolve surface "missing"/
+  );
+
+  assert.throws(
+    () =>
+      resolveCrudSurfacePolicy(
+        {
+          surface: "console",
+          ownershipFilter: "auto",
+          relativePath: "/crm/customers"
+        },
+        {
+          surfaceDefinitions: {
+            console: { requiresWorkspace: false, requiresAuth: true, enabled: false }
+          }
+        }
+      ),
+    /surface "console" is disabled/
+  );
+});