@jskit-ai/crud-server-generator 0.1.41 → 0.1.42

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-server-generator",
-  version: "0.1.41",
+  version: "0.1.42",
   kind: "generator",
   description: "CRUD server generator with routes, actions, and persistence scaffolding.",
   options: {
@@ -13,16 +13,18 @@ export default Object.freeze({
       promptHint: "Required slug (example: customers, appointments, vendors)."
     },
     surface: {
-      required: true,
+      required: false,
       inputType: "text",
       validationType: "enabled-surface-id",
       promptLabel: "Target surface",
-      promptHint: "Must match an enabled surface id."
+      promptHint: "Optional for non-workspace apps; otherwise must match an enabled surface id."
     },
     "ownership-filter": {
       required: true,
       inputType: "text",
       defaultValue: "auto",
+      validationType: "enum",
+      allowedValues: ["auto", "public", "user", "workspace", "workspace_user"],
       promptLabel: "Ownership filter",
       promptHint: "auto | public | user | workspace | workspace_user"
     },
@@ -34,11 +36,12 @@ export default Object.freeze({
       promptHint: "Optional subpath prepended to the CRUD route path (example: crm or ops/team-a)."
     },
     "table-name": {
-      required: true,
+      required: false,
       inputType: "text",
       defaultValue: "",
+      defaultFromOptionTemplate: "${option:namespace}",
       promptLabel: "Table name",
-      promptHint: "Required existing MySQL table to introspect for CRUD schema generation."
+      promptHint: "Existing MySQL table to introspect for CRUD schema generation (defaults to namespace)."
     },
     "id-column": {
       required: false,
@@ -148,13 +151,13 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.32",
-        "@jskit-ai/crud-core": "0.1.41",
-        "@jskit-ai/database-runtime": "0.1.33",
-        "@jskit-ai/http-runtime": "0.1.32",
-        "@jskit-ai/kernel": "0.1.33",
-        "@jskit-ai/realtime": "0.1.32",
-        "@jskit-ai/users-core": "0.1.43",
+        "@jskit-ai/auth-core": "0.1.33",
+        "@jskit-ai/crud-core": "0.1.42",
+        "@jskit-ai/database-runtime": "0.1.34",
+        "@jskit-ai/http-runtime": "0.1.33",
+        "@jskit-ai/kernel": "0.1.34",
+        "@jskit-ai/realtime": "0.1.33",
+        "@jskit-ai/users-core": "0.1.44",
         "@local/${option:namespace|kebab}": "file:packages/${option:namespace|kebab}",
         "typebox": "^1.0.81"
       },
@@ -208,7 +211,11 @@ export default Object.freeze({
         to: "packages/${option:namespace|kebab}/src/server/actions.js",
         reason: "Install app-local CRUD action definitions.",
         category: "crud",
-        id: "crud-local-package-server-actions-${option:namespace|snake}"
+        id: "crud-local-package-server-actions-${option:namespace|snake}",
+        templateContext: {
+          entrypoint: "src/server/buildTemplateContext.js",
+          export: "buildTemplateContext"
+        }
       },
       {
         from: "templates/src/local-package/server/actionIds.js",
@@ -233,7 +240,11 @@ export default Object.freeze({
         to: "packages/${option:namespace|kebab}/src/server/registerRoutes.js",
         reason: "Install app-local CRUD route registration.",
         category: "crud",
-        id: "crud-local-package-server-routes-${option:namespace|snake}"
+        id: "crud-local-package-server-routes-${option:namespace|snake}",
+        templateContext: {
+          entrypoint: "src/server/buildTemplateContext.js",
+          export: "buildTemplateContext"
+        }
       },
       {
         from: "templates/src/local-package/server/repository.js",
@@ -278,11 +289,14 @@ export default Object.freeze({
         file: "config/roles.js",
         position: "bottom",
         skipIfContains: "\"crud.${option:namespace|snake}.list\"",
-        value:
-          "\nroleCatalog.roles.member.permissions.push(\n  \"crud.${option:namespace|snake}.list\",\n  \"crud.${option:namespace|snake}.view\",\n  \"crud.${option:namespace|snake}.create\",\n  \"crud.${option:namespace|snake}.update\",\n  \"crud.${option:namespace|snake}.delete\"\n);\n",
+        value: "__JSKIT_CRUD_ROLE_CATALOG_PERMISSION_GRANTS__",
         reason: "Grant generated CRUD action permissions to the default member role in the app-owned role catalog.",
         category: "crud",
-        id: "crud-role-catalog-permissions-${option:namespace|snake}"
+        id: "crud-role-catalog-permissions-${option:namespace|snake}",
+        templateContext: {
+          entrypoint: "src/server/buildTemplateContext.js",
+          export: "buildTemplateContext"
+        }
       }
     ]
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-server-generator",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -13,11 +13,11 @@
   },
   "dependencies": {
     "@babel/parser": "^7.29.2",
-    "@jskit-ai/crud-core": "0.1.41",
-    "@jskit-ai/database-runtime": "0.1.33",
-    "@jskit-ai/http-runtime": "0.1.32",
-    "@jskit-ai/kernel": "0.1.33",
-    "@jskit-ai/users-core": "0.1.43",
+    "@jskit-ai/crud-core": "0.1.42",
+    "@jskit-ai/database-runtime": "0.1.34",
+    "@jskit-ai/http-runtime": "0.1.33",
+    "@jskit-ai/kernel": "0.1.34",
+    "@jskit-ai/users-core": "0.1.44",
     "recast": "^0.23.11",
     "typebox": "^1.0.81"
   }

package/src/server/buildTemplateContext.js

@@ -8,20 +8,51 @@ import {
   resolveKnexConnectionFromEnvironment,
   toKnexClientId
 } from "@jskit-ai/database-runtime/shared";
+import { resolveCrudSurfacePolicyFromAppConfig } from "@jskit-ai/crud-core/server/crudModuleConfig";
 import { checkCrudLookupFormControl } from "@jskit-ai/crud-core/shared/crudFieldMetaSupport";
+import {
+  importFreshModuleFromAbsolutePath,
+  loadAppConfigFromModuleUrl,
+  resolveRequiredAppRoot
+} from "@jskit-ai/kernel/server/support";
 import { normalizeCrudLookupNamespace } from "@jskit-ai/kernel/shared/support/crudLookup";
 import { toCamelCase, toSnakeCase } from "@jskit-ai/kernel/shared/support/stringCase";
+import descriptor from "../../package.descriptor.mjs";
 
 const DEFAULT_ID_COLUMN = "id";
-const OWNERSHIP_FILTER_AUTO = "auto";
-const OWNERSHIP_FILTER_VALUES = new Set([
-  OWNERSHIP_FILTER_AUTO,
-  "public",
-  "user",
-  "workspace",
-  "workspace_user"
-]);
+const DEFAULT_OWNERSHIP_FILTER_VALUES = Object.freeze(["auto", "public", "user", "workspace", "workspace_user"]);
 const MYSQL_CLIENT_ID = "mysql2";
+const CRUD_PERMISSION_OPERATIONS = Object.freeze(["list", "view", "create", "update", "delete"]);
+
+function resolveAllowedValues(schema = {}, fallbackValues = []) {
+  const resolvedValues = [];
+  const seen = new Set();
+  for (const rawValue of Array.isArray(schema?.allowedValues) ? schema.allowedValues : []) {
+    const value = normalizeText(typeof rawValue === "string" ? rawValue : rawValue?.value).toLowerCase();
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    resolvedValues.push(value);
+  }
+  if (resolvedValues.length > 0) {
+    return Object.freeze(resolvedValues);
+  }
+  return Object.freeze(
+    (Array.isArray(fallbackValues) ? fallbackValues : [])
+      .map((value) => normalizeText(value).toLowerCase())
+      .filter(Boolean)
+  );
+}
+
+const OWNERSHIP_FILTER_ALLOWED_VALUES = resolveAllowedValues(
+  descriptor?.options?.["ownership-filter"],
+  DEFAULT_OWNERSHIP_FILTER_VALUES
+);
+const OWNERSHIP_FILTER_AUTO = normalizeText(
+  descriptor?.options?.["ownership-filter"]?.defaultValue
+).toLowerCase() || "auto";
+const OWNERSHIP_FILTER_VALUES = new Set(OWNERSHIP_FILTER_ALLOWED_VALUES);
 
 function resolveGlobalScaffoldCache() {
   const globalObject = globalThis;
@@ -54,7 +85,7 @@ function normalizeRequestedOwnershipFilter(value, { strict = false } = {}) {
   }
   if (strict) {
     throw new Error(
-      `Invalid ownership filter "${normalized || String(value || "")}". Use: auto, public, user, workspace, workspace_user.`
+      `Invalid ownership filter "${normalized || String(value || "")}". Use: ${OWNERSHIP_FILTER_ALLOWED_VALUES.join(", ")}.`
     );
   }
   return OWNERSHIP_FILTER_AUTO;
@@ -187,7 +218,7 @@ async function importModuleFromApp(appRequire, moduleId, contextLabel) {
   }
 
   try {
-    return await import(`${pathToFileURL(resolvedPath).href}?t=${Date.now()}_${Math.random()}`);
+    return await importFreshModuleFromAbsolutePath(resolvedPath);
   } catch (error) {
     throw new Error(
       `${contextLabel} failed loading "${moduleId}": ${String(error?.message || error || "unknown error")}`
@@ -195,6 +226,99 @@ async function importModuleFromApp(appRequire, moduleId, contextLabel) {
   }
 }
 
+async function resolveCrudSurfaceRequiresWorkspace({
+  appRoot,
+  options,
+  surface = ""
+} = {}) {
+  const namespace = normalizeText(options?.namespace);
+  const resolvedSurface = normalizeText(surface || options?.surface);
+  if (!namespace) {
+    throw new Error('crud template context requires option "namespace".');
+  }
+  if (!resolvedSurface) {
+    throw new Error('crud template context requires option "surface".');
+  }
+
+  const appConfig = await loadCrudAppConfig(appRoot);
+  const crudPolicy = resolveCrudSurfacePolicyFromAppConfig(
+    {
+      namespace,
+      surface: resolvedSurface,
+      ownershipFilter: options?.["ownership-filter"]
+    },
+    appConfig,
+    {
+      context: "crud template context"
+    }
+  );
+
+  return crudPolicy?.surfaceDefinition?.requiresWorkspace === true;
+}
+
+async function loadCrudAppConfig(appRoot = "") {
+  const resolvedAppRoot = resolveRequiredAppRoot(appRoot, {
+    context: "crud template context"
+  });
+  return loadAppConfigFromModuleUrl({
+    moduleUrl: pathToFileURL(path.join(resolvedAppRoot, "config", "public.js")).href
+  });
+}
+
+function resolveSurfaceDefinitions(appConfig = {}) {
+  const definitions = asRecord(appConfig?.surfaceDefinitions);
+  const resolved = {};
+  for (const [key, rawValue] of Object.entries(definitions)) {
+    const definition = asRecord(rawValue);
+    const id = normalizeText(definition.id || key).toLowerCase();
+    if (!id) {
+      continue;
+    }
+    resolved[id] = Object.freeze({
+      id,
+      enabled: definition.enabled !== false,
+      requiresWorkspace: definition.requiresWorkspace === true
+    });
+  }
+  return Object.freeze(resolved);
+}
+
+function resolveDefaultCrudSurfaceIdFromAppConfig(appConfig = {}) {
+  const surfaceDefinitions = resolveSurfaceDefinitions(appConfig);
+  const enabledSurfaceDefinitions = Object.values(surfaceDefinitions).filter((entry) => entry.enabled === true);
+  const hasEnabledWorkspaceSurface = enabledSurfaceDefinitions.some((entry) => entry.requiresWorkspace === true);
+  if (hasEnabledWorkspaceSurface) {
+    return "";
+  }
+
+  const homeSurface = surfaceDefinitions.home;
+  if (homeSurface?.enabled === true && homeSurface.requiresWorkspace !== true) {
+    return "home";
+  }
+
+  return "";
+}
+
+async function resolveCrudGenerationSurfaceId({
+  appRoot,
+  options
+} = {}) {
+  const explicitSurface = normalizeText(options?.surface).toLowerCase();
+  if (explicitSurface) {
+    return explicitSurface;
+  }
+
+  const appConfig = await loadCrudAppConfig(appRoot);
+  const defaultSurface = resolveDefaultCrudSurfaceIdFromAppConfig(appConfig);
+  if (defaultSurface) {
+    return defaultSurface;
+  }
+
+  throw new Error(
+    'crud template context requires option "surface" when the app has any enabled workspace surface or no enabled non-workspace "home" surface.'
+  );
+}
+
 function resolveKnexFactory(moduleNamespace) {
   if (typeof moduleNamespace === "function") {
     return moduleNamespace;
@@ -1231,10 +1355,184 @@ function renderRepositoryListConfigLines(snapshot = {}) {
   ].join("\n");
 }
 
+function buildCrudPermissionIds(namespace = "") {
+  const permissionNamespace = toSnakeCase(namespace);
+  if (!permissionNamespace) {
+    return null;
+  }
+
+  return Object.freeze(
+    Object.fromEntries(
+      CRUD_PERMISSION_OPERATIONS.map((operation) => [operation, `crud.${permissionNamespace}.${operation}`])
+    )
+  );
+}
+
+function normalizeCrudOperation(operation = "", context = "CRUD operation") {
+  const normalizedOperation = normalizeText(operation).toLowerCase();
+  if (!CRUD_PERMISSION_OPERATIONS.includes(normalizedOperation)) {
+    throw new Error(`Unknown ${context} "${normalizedOperation || String(operation || "")}".`);
+  }
+  return normalizedOperation;
+}
+
+function renderRoleCatalogPermissionGrants(namespace = "", { requiresNamedPermissions = true } = {}) {
+  const permissionIds = buildCrudPermissionIds(namespace);
+  if (!requiresNamedPermissions || !permissionIds) {
+    return "";
+  }
+
+  return [
+    "roleCatalog.roles.member.permissions.push(",
+    `  ${JSON.stringify(permissionIds.list)},`,
+    `  ${JSON.stringify(permissionIds.view)},`,
+    `  ${JSON.stringify(permissionIds.create)},`,
+    `  ${JSON.stringify(permissionIds.update)},`,
+    `  ${JSON.stringify(permissionIds.delete)}`,
+    ");"
+  ].join("\n");
+}
+
+function renderActionPermissionSupport(namespace = "", { requiresNamedPermissions = true } = {}) {
+  if (!requiresNamedPermissions) {
+    return [
+      "const authenticatedPermission = Object.freeze({",
+      '  require: "authenticated"',
+      "});"
+    ].join("\n");
+  }
+
+  const permissionIds = buildCrudPermissionIds(namespace);
+  if (!permissionIds) {
+    return "";
+  }
+
+  return [
+    "const actionPermissions = Object.freeze({",
+    `  list: ${JSON.stringify(permissionIds.list)},`,
+    `  view: ${JSON.stringify(permissionIds.view)},`,
+    `  create: ${JSON.stringify(permissionIds.create)},`,
+    `  update: ${JSON.stringify(permissionIds.update)},`,
+    `  delete: ${JSON.stringify(permissionIds.delete)}`,
+    "});"
+  ].join("\n");
+}
+
+function renderActionPermissionExpression(operation = "", { requiresNamedPermissions = true } = {}) {
+  const normalizedOperation = normalizeCrudOperation(operation, "CRUD permission operation");
+
+  if (!requiresNamedPermissions) {
+    return "authenticatedPermission";
+  }
+
+  return `{ require: "all", permissions: [actionPermissions.${normalizedOperation}] }`;
+}
+
+function renderRouteWorkspaceSupportImports({ surfaceRequiresWorkspace = true } = {}) {
+  if (!surfaceRequiresWorkspace) {
+    return "";
+  }
+
+  return [
+    'import { routeParamsValidator } from "@jskit-ai/users-core/server/validators/routeParamsValidator";',
+    'import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/users-core/server/support/workspaceRouteInput";'
+  ].join("\n");
+}
+
+function renderActionWorkspaceValidatorImport({ surfaceRequiresWorkspace = true } = {}) {
+  if (!surfaceRequiresWorkspace) {
+    return "";
+  }
+
+  return 'import { workspaceSlugParamsValidator } from "@jskit-ai/users-core/server/validators/routeParamsValidator";';
+}
+
+function renderRouteParamsValidatorLine(operation = "", { surfaceRequiresWorkspace = true } = {}) {
+  const normalizedOperation = normalizeCrudOperation(operation, "CRUD route params validator operation");
+  if (normalizedOperation === "list" || normalizedOperation === "create") {
+    if (!surfaceRequiresWorkspace) {
+      return "";
+    }
+    return "      paramsValidator: routeParamsValidator,";
+  }
+
+  if (!surfaceRequiresWorkspace) {
+    return "      paramsValidator: recordIdParamsValidator,";
+  }
+
+  return "      paramsValidator: [routeParamsValidator, recordIdParamsValidator],";
+}
+
+function renderRouteInputLines(operation = "", { surfaceRequiresWorkspace = true } = {}) {
+  const normalizedOperation = normalizeCrudOperation(operation, "CRUD route input operation");
+  const lines = [];
+
+  if (surfaceRequiresWorkspace) {
+    lines.push("          ...buildWorkspaceInputFromRouteParams(request.input.params),");
+  }
+
+  if (normalizedOperation === "list") {
+    lines.push("          ...(request.input.query || {})");
+    return lines.join("\n");
+  }
+
+  if (normalizedOperation === "view") {
+    lines.push("          recordId: request.input.params.recordId,");
+    lines.push("          ...(request.input.query || {})");
+    return lines.join("\n");
+  }
+
+  if (normalizedOperation === "create") {
+    lines.push("          payload: request.input.body");
+    return lines.join("\n");
+  }
+
+  if (normalizedOperation === "update") {
+    lines.push("          recordId: request.input.params.recordId,");
+    lines.push("          patch: request.input.body");
+    return lines.join("\n");
+  }
+
+  lines.push("          recordId: request.input.params.recordId");
+  return lines.join("\n");
+}
+
+function renderActionInputValidatorExpression(operation = "", { surfaceRequiresWorkspace = true } = {}) {
+  const normalizedOperation = normalizeCrudOperation(operation, "CRUD action input validator operation");
+  const validators = [];
+
+  if (surfaceRequiresWorkspace) {
+    validators.push("workspaceSlugParamsValidator");
+  }
+
+  if (normalizedOperation === "list") {
+    validators.push(
+      "listCursorPaginationQueryValidator",
+      "listSearchQueryValidator",
+      "listParentFilterQueryValidator",
+      "lookupIncludeQueryValidator"
+    );
+  } else if (normalizedOperation === "view") {
+    validators.push("recordIdParamsValidator", "lookupIncludeQueryValidator");
+  } else if (normalizedOperation === "create") {
+    validators.push("{ payload: resource.operations.create.bodyValidator }");
+  } else if (normalizedOperation === "update") {
+    validators.push("recordIdParamsValidator", "{ patch: resource.operations.patch.bodyValidator }");
+  } else {
+    validators.push("recordIdParamsValidator");
+  }
+
+  return validators.length === 1 ? validators[0] : `[${validators.join(", ")}]`;
+}
+
 function buildReplacementsFromSnapshot({
+  namespace = "",
   snapshot,
-  resolvedOwnershipFilter
+  resolvedOwnershipFilter,
+  surfaceRequiresWorkspace = true,
+  surfaceId = ""
 }) {
+  const requiresNamedPermissions = surfaceRequiresWorkspace === true;
   const scaffoldColumns = resolveScaffoldColumns(snapshot);
   const outputColumns = scaffoldColumns.filter((column) => !column.isOwnerColumn);
   const writableColumns = scaffoldColumns.filter((column) => column.writable);
@@ -1275,7 +1573,81 @@ function buildReplacementsFromSnapshot({
   const replacements = Object.freeze({
     __JSKIT_CRUD_TABLE_NAME__: JSON.stringify(snapshot.tableName),
     __JSKIT_CRUD_ID_COLUMN__: JSON.stringify(snapshot.idColumn || DEFAULT_ID_COLUMN),
+    __JSKIT_CRUD_SURFACE_ID__: JSON.stringify(normalizeText(surfaceId).toLowerCase()),
     __JSKIT_CRUD_RESOLVED_OWNERSHIP_FILTER__: resolvedOwnershipFilter,
+    __JSKIT_CRUD_ACTION_PERMISSION_SUPPORT__: renderActionPermissionSupport(namespace, {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_ACTION_WORKSPACE_VALIDATOR_IMPORT__: renderActionWorkspaceValidatorImport({
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_LIST_ACTION_PERMISSION__: renderActionPermissionExpression("list", {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_LIST_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("list", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_VIEW_ACTION_PERMISSION__: renderActionPermissionExpression("view", {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_VIEW_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("view", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_CREATE_ACTION_PERMISSION__: renderActionPermissionExpression("create", {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_CREATE_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("create", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_UPDATE_ACTION_PERMISSION__: renderActionPermissionExpression("update", {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_UPDATE_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("update", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_DELETE_ACTION_PERMISSION__: renderActionPermissionExpression("delete", {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_DELETE_ACTION_INPUT_VALIDATOR__: renderActionInputValidatorExpression("delete", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_ROLE_CATALOG_PERMISSION_GRANTS__: renderRoleCatalogPermissionGrants(namespace, {
+      requiresNamedPermissions
+    }),
+    __JSKIT_CRUD_ROUTE_SURFACE_REQUIRES_WORKSPACE__: String(surfaceRequiresWorkspace === true),
+    __JSKIT_CRUD_ROUTE_WORKSPACE_SUPPORT_IMPORTS__: renderRouteWorkspaceSupportImports({
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_LIST_ROUTE_PARAMS_VALIDATOR_LINE__: renderRouteParamsValidatorLine("list", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_VIEW_ROUTE_PARAMS_VALIDATOR_LINE__: renderRouteParamsValidatorLine("view", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_CREATE_ROUTE_PARAMS_VALIDATOR_LINE__: renderRouteParamsValidatorLine("create", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_UPDATE_ROUTE_PARAMS_VALIDATOR_LINE__: renderRouteParamsValidatorLine("update", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_DELETE_ROUTE_PARAMS_VALIDATOR_LINE__: renderRouteParamsValidatorLine("delete", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_LIST_ROUTE_INPUT_LINES__: renderRouteInputLines("list", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_VIEW_ROUTE_INPUT_LINES__: renderRouteInputLines("view", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_CREATE_ROUTE_INPUT_LINES__: renderRouteInputLines("create", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_UPDATE_ROUTE_INPUT_LINES__: renderRouteInputLines("update", {
+      surfaceRequiresWorkspace
+    }),
+    __JSKIT_CRUD_DELETE_ROUTE_INPUT_LINES__: renderRouteInputLines("delete", {
+      surfaceRequiresWorkspace
+    }),
     __JSKIT_CRUD_RESOURCE_VALIDATORS_IMPORT__: renderResourceValidatorsImport({
       needsHtmlTimeSchemas,
       needsRecordIdSchemas
@@ -1334,11 +1706,16 @@ async function resolveGenerationSnapshot({
   });
 }
 
+function resolveCrudGenerationTableName(options = {}) {
+  return normalizeText(options?.["table-name"] || options?.namespace);
+}
+
 function createCacheKey({ appRoot, options }) {
   const payload = {
     appRoot: path.resolve(String(appRoot || "")),
     options: {
       namespace: normalizeText(options?.namespace),
+      surface: normalizeText(options?.surface),
       ownershipFilter: normalizeText(options?.["ownership-filter"]),
       tableName: normalizeText(options?.["table-name"]),
       idColumn: normalizeText(options?.["id-column"])
@@ -1356,10 +1733,14 @@ async function buildCrudTemplateContext(input = {}) {
   if (!namespace) {
     throw new Error('crud template context requires option "namespace".');
   }
-  const tableName = normalizeText(options["table-name"]);
+  const tableName = resolveCrudGenerationTableName(options);
   if (!tableName) {
     throw new Error('crud template context requires option "table-name".');
   }
+  const resolvedSurface = await resolveCrudGenerationSurfaceId({
+    appRoot,
+    options
+  });
   const snapshot = await resolveGenerationSnapshot({
     appRoot,
     tableName,
@@ -1373,10 +1754,18 @@ async function buildCrudTemplateContext(input = {}) {
       enforceTableColumns: true
     }
   );
+  const surfaceRequiresWorkspace = await resolveCrudSurfaceRequiresWorkspace({
+    appRoot,
+    options,
+    surface: resolvedSurface
+  });
 
   return buildReplacementsFromSnapshot({
+    namespace,
     snapshot,
-    resolvedOwnershipFilter
+    resolvedOwnershipFilter,
+    surfaceRequiresWorkspace,
+    surfaceId: resolvedSurface
   });
 }
 
@@ -1408,8 +1797,19 @@ const __testables = Object.freeze({
   renderResourceFieldSchema,
   renderInputNormalizer,
   renderOutputNormalizerExpression,
+  resolveCrudGenerationTableName,
   resolveGenerationSnapshot,
-  buildFieldMetaEntries
+  buildFieldMetaEntries,
+  resolveDefaultCrudSurfaceIdFromAppConfig,
+  resolveCrudGenerationSurfaceId,
+  resolveCrudSurfaceRequiresWorkspace,
+  buildCrudPermissionIds,
+  renderRoleCatalogPermissionGrants,
+  renderActionPermissionSupport,
+  renderActionPermissionExpression,
+  renderActionInputValidatorExpression,
+  renderRouteParamsValidatorLine,
+  renderRouteInputLines
 });
 
 export {
@@ -1421,5 +1821,6 @@ export {
   renderInputNormalizer,
   renderOutputNormalizerExpression,
   buildFieldMetaEntries,
+  resolveCrudGenerationSurfaceId,
   __testables
 };

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

@@ -14,7 +14,7 @@ import { createActions } from "./actions.js";
 import { registerRoutes } from "./registerRoutes.js";
 const CRUD_MODULE_CONFIG = Object.freeze({
   namespace: "${option:namespace|snake}",
-  surface: "${option:surface|lower}",
+  surface: __JSKIT_CRUD_SURFACE_ID__,
   ownershipFilter: "__JSKIT_CRUD_RESOLVED_OWNERSHIP_FILTER__",
   relativePath: "/${option:directory-prefix|pathprefix}${option:namespace|kebab}"
 });
@@ -82,7 +82,6 @@ class ${option:namespace|pascal}Provider {
     registerRoutes(app, {
       routeOwnershipFilter: crudPolicy.ownershipFilter,
       routeSurface: crudPolicy.surfaceId,
-      routeSurfaceRequiresWorkspace: crudPolicy.surfaceDefinition.requiresWorkspace === true,
       routeRelativePath: crudPolicy.relativePath
     });
   }