slskit-cli 1.0.0

package/dist/commands/init/content.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileMap = buildFileMap;
+const environments_js_1 = require("../../core/environments.js");
+const manifest_js_1 = require("./manifest.js");
+const types_js_1 = require("./types.js");
+const helpers_js_1 = require("./templates/helpers.js");
+const project_js_1 = require("./templates/project.js");
+const shared_code_js_1 = require("./templates/shared-code.js");
+const node_js_1 = require("./templates/node.js");
+const python_js_1 = require("./templates/python.js");
+const sam_js_1 = require("./templates/sam.js");
+function handlerSource(answers, appName, fn) {
+    if (answers.runtime === "python") {
+        return (0, python_js_1.pythonHandler)(appName, fn);
+    }
+    return (0, node_js_1.nodeHandler)(answers, appName, fn, answers.runtime === "typescript");
+}
+function serviceSource(answers, fn) {
+    if (answers.runtime === "python") {
+        return (0, python_js_1.pythonService)(answers, fn);
+    }
+    return (0, node_js_1.nodeService)(answers, fn, answers.runtime === "typescript");
+}
+function dotenvKeys(body) {
+    return body
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#") && line.includes("="))
+        .map((line) => line.slice(0, line.indexOf("=")).trim())
+        .filter((key) => key && key !== environments_js_1.APP_ENVIRONMENT_KEY);
+}
+function buildFileMap(answers, envKeys = []) {
+    const files = {
+        ".gitignore": (0, project_js_1.gitignore)(answers.runtime),
+        "README.md": (0, project_js_1.readme)(answers),
+        "package.json": (0, project_js_1.packageJson)(answers),
+    };
+    // Exactly one environment file. Every other environment is created later by
+    // "slskit env add", which writes its own .env.<name> alongside this one.
+    const dotenv = (0, project_js_1.environmentDotenv)(environments_js_1.DEFAULT_ENVIRONMENT, answers.database);
+    files[`.env.${environments_js_1.DEFAULT_ENVIRONMENT}`] = dotenv;
+    // Whatever init seeds into that file (DATABASE_URL and friends) is an ordinary
+    // stage variable, so the templates have to declare a parameter for it too.
+    const keys = [...new Set([...envKeys, ...dotenvKeys(dotenv)])].sort();
+    if (answers.runtime === "typescript") {
+        files["tsconfig.json"] = (0, project_js_1.tsconfig)(answers);
+    }
+    if (answers.runtime === "python") {
+        files["requirements.txt"] = (0, project_js_1.requirementsTxt)(answers);
+        files[`${types_js_1.SRC_DIR}/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/functions/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/services/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/shared/__init__.py`] = "";
+        if (answers.layer) {
+            files[`${types_js_1.SRC_DIR}/shared/python/__init__.py`] = "";
+        }
+    }
+    files["template.yaml"] = (0, sam_js_1.samRootTemplate)(answers, types_js_1.LAMBDA_APPS, keys);
+    const sharedDir = (0, types_js_1.sharedCodeDir)(answers);
+    const isNodeLayer = answers.layer && answers.runtime !== "python";
+    // A real Lambda layer is deployed raw, never esbuild-bundled, so it must ship plain CommonJS.
+    const loggerFileExt = isNodeLayer ? "js" : (0, helpers_js_1.loggerExt)(answers.runtime);
+    files[`${sharedDir}/logger.${loggerFileExt}`] = isNodeLayer
+        ? (0, shared_code_js_1.sharedLayerLogger)()
+        : (0, shared_code_js_1.sharedLogger)(answers.runtime);
+    if (isNodeLayer && answers.runtime === "typescript") {
+        files[`${sharedDir}/logger.d.ts`] = (0, shared_code_js_1.sharedLayerLoggerTypes)();
+    }
+    // db stays out of the layer: a layer ships no node_modules, so anything importing a
+    // database client must be packaged with the function instead.
+    const db = (0, shared_code_js_1.sharedDb)(answers);
+    if (db) {
+        files[`${types_js_1.SRC_DIR}/shared/db.${(0, types_js_1.sourceExt)(answers.runtime)}`] = db;
+    }
+    if (answers.database === "prisma") {
+        files["prisma/schema.prisma"] = (0, shared_code_js_1.prismaSchema)();
+    }
+    const serviceExt = (0, types_js_1.sourceExt)(answers.runtime);
+    for (const app of types_js_1.LAMBDA_APPS) {
+        if (answers.runtime === "python") {
+            files[`${types_js_1.SRC_DIR}/functions/${app.name}/__init__.py`] = "";
+            files[`${types_js_1.SRC_DIR}/services/${app.name}/__init__.py`] = "";
+        }
+        files[(0, types_js_1.serviceTemplatePath)(app.name)] = (0, sam_js_1.samServiceTemplate)(answers, app, keys);
+        for (const fn of app.functions) {
+            if (answers.runtime === "python") {
+                files[`${types_js_1.SRC_DIR}/functions/${app.name}/${fn.name}/__init__.py`] = "";
+            }
+            files[`${types_js_1.SRC_DIR}/functions/${app.name}/${fn.name}/${(0, types_js_1.handlerFileName)(answers.runtime)}`] = handlerSource(answers, app.name, fn);
+            files[`${types_js_1.SRC_DIR}/services/${app.name}/${fn.name}.${serviceExt}`] =
+                serviceSource(answers, fn);
+        }
+    }
+    files["slskit.json"] = `${JSON.stringify((0, manifest_js_1.buildProjectManifest)(answers, types_js_1.LAMBDA_APPS, Object.keys(files)), null, 2)}\n`;
+    return files;
+}

package/dist/commands/init/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInitCommand(program: Command): void;

package/dist/commands/init/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInitCommand = registerInitCommand;
+const run_js_1 = require("../../core/run.js");
+function registerInitCommand(program) {
+    program
+        .command("init")
+        .description("Scaffold a multi-service AWS SAM project")
+        .argument("[name]", "Project name (example: my-lambda-app)")
+        .option("-r, --runtime <runtime>", "typescript | javascript | python")
+        .option("--database <database>", "none | prisma | mongoose | dynamodb")
+        .option("--api-gateway <yes|no>", "Expose the functions over HTTP")
+        .option("--shared-api <yes|no>", "One API Gateway for every function (default: no — one per service)")
+        .option("--layer <yes|no>", "Use shared/ as a common Lambda layer")
+        .option("--memory <mb>", "Function memory size: 128 | 256 | 512 | 1024 | 2048 | 3008 | 4096 | 10240")
+        .option("-f, --force", "Overwrite files if the folder already exists", false)
+        .action((name, options) => (0, run_js_1.runCommand)(async () => {
+        const { initAction } = await import("./action.js");
+        await initAction({
+            name: name ?? options.name,
+            runtime: options.runtime,
+            database: options.database,
+            apiGateway: options.apiGateway,
+            sharedApi: options.sharedApi,
+            layer: options.layer,
+            memory: options.memory,
+            force: options.force,
+        });
+    }));
+}

package/dist/commands/init/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { InitAnswers, ServiceDef } from "./types.js";
+export interface PreservedState {
+    version?: string;
+    environments?: unknown;
+}
+export declare function buildProjectManifest(answers: InitAnswers, apps: ServiceDef[], generatedFiles: string[], preserved?: PreservedState): Record<string, unknown>;

package/dist/commands/init/manifest.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectManifest = buildProjectManifest;
+const environments_js_1 = require("../../core/environments.js");
+const types_js_1 = require("./types.js");
+// Handler paths are relative to the Lambda CodeUri, which is the project root.
+function handlerValue(runtime, appName, fnName) {
+    if (runtime === "python") {
+        return `${types_js_1.SRC_DIR}.functions.${appName}.${fnName}.handler.handler`;
+    }
+    return `${types_js_1.SRC_DIR}/functions/${appName}/${fnName}/handler.handler`;
+}
+function buildProjectManifest(answers, apps, generatedFiles, preserved = {}) {
+    const sharedDir = (0, types_js_1.sharedCodeDir)(answers);
+    const applications = apps.map((app) => ({
+        name: app.name,
+        path: `${types_js_1.SRC_DIR}/functions/${app.name}`,
+        template: answers.sharedApi ? types_js_1.INFRA_FILE : (0, types_js_1.serviceTemplatePath)(app.name),
+        functions: app.functions.map((fn) => {
+            const fnRuntime = fn.runtime ?? answers.runtime;
+            const sameFamily = (0, types_js_1.sameRuntimeFamily)(fnRuntime, answers.runtime);
+            const attachesLayer = answers.layer && sameFamily;
+            return {
+                id: `${app.name}.${fn.name}`,
+                name: fn.name,
+                path: `${types_js_1.SRC_DIR}/functions/${app.name}/${fn.name}`,
+                handlerFile: `${types_js_1.SRC_DIR}/functions/${app.name}/${fn.name}/${(0, types_js_1.handlerFileName)(fnRuntime)}`,
+                handler: handlerValue(fnRuntime, app.name, fn.name),
+                service: {
+                    application: app.name,
+                    path: `${types_js_1.SRC_DIR}/services/${app.name}/${fn.name}.${(0, types_js_1.sourceExt)(fnRuntime)}`,
+                    export: fn.name,
+                },
+                runtime: (0, types_js_1.lambdaRuntime)(fnRuntime),
+                memorySize: fn.memorySize ?? answers.memorySize,
+                apiGateway: answers.apiGateway
+                    ? {
+                        enabled: true,
+                        gateway: answers.sharedApi ? `${answers.name}-http-api` : app.name,
+                        path: fn.httpPath,
+                        method: fn.method,
+                    }
+                    : { enabled: false },
+                layer: attachesLayer
+                    ? { enabled: true, name: "shared", path: `${types_js_1.SRC_DIR}/shared` }
+                    : { enabled: false },
+            };
+        }),
+    }));
+    const services = apps.map((app) => ({
+        application: app.name,
+        path: `${types_js_1.SRC_DIR}/services/${app.name}`,
+        files: app.functions.map((fn) => `${types_js_1.SRC_DIR}/services/${app.name}/${fn.name}.${(0, types_js_1.sourceExt)(fn.runtime ?? answers.runtime)}`),
+    }));
+    const routes = answers.apiGateway
+        ? apps.flatMap((app) => app.functions.map((fn) => ({
+            path: fn.httpPath,
+            method: fn.method,
+            function: `${app.name}.${fn.name}`,
+        })))
+        : [];
+    const directories = [
+        types_js_1.SRC_DIR,
+        `${types_js_1.SRC_DIR}/functions`,
+        `${types_js_1.SRC_DIR}/services`,
+        ...apps.flatMap((app) => [
+            `${types_js_1.SRC_DIR}/functions/${app.name}`,
+            ...app.functions.map((fn) => `${types_js_1.SRC_DIR}/functions/${app.name}/${fn.name}`),
+            `${types_js_1.SRC_DIR}/services/${app.name}`,
+        ]),
+        sharedDir,
+        ...(answers.sharedApi ? [] : [types_js_1.TEMPLATES_DIR]),
+        ...(answers.database === "prisma" ? ["prisma"] : []),
+    ];
+    const layerAttachedTo = apps.flatMap((app) => app.functions
+        .filter((fn) => (0, types_js_1.sameRuntimeFamily)(fn.runtime ?? answers.runtime, answers.runtime))
+        .map((fn) => `${app.name}.${fn.name}`));
+    return {
+        name: answers.name,
+        version: preserved.version ?? "0.1.0",
+        generatedBy: "slskit",
+        runtime: {
+            id: answers.runtime,
+            lambda: (0, types_js_1.lambdaRuntime)(answers.runtime),
+        },
+        framework: {
+            id: "sam",
+            files: {
+                root: types_js_1.INFRA_FILE,
+                application: types_js_1.INFRA_FILE,
+                applications: answers.sharedApi
+                    ? []
+                    : apps.map((app) => (0, types_js_1.serviceTemplatePath)(app.name)),
+            },
+        },
+        database: {
+            id: answers.database,
+            enabled: answers.database !== "none",
+        },
+        functions: {
+            memorySize: answers.memorySize,
+        },
+        apiGateway: answers.apiGateway
+            ? {
+                enabled: true,
+                name: `${answers.name}-http-api`,
+                type: "HttpApi",
+                // SAM only resolves an ApiId inside the template that declares the API, so
+                // one shared API means one flat template and per-service APIs mean one each.
+                perService: !answers.sharedApi,
+                templates: answers.sharedApi
+                    ? [types_js_1.INFRA_FILE]
+                    : apps.map((app) => (0, types_js_1.serviceTemplatePath)(app.name)),
+                attachAllFunctions: true,
+                routes,
+            }
+            : { enabled: false },
+        layer: answers.layer
+            ? {
+                enabled: true,
+                name: `${answers.name}-shared`,
+                path: `${types_js_1.SRC_DIR}/shared`,
+                source: sharedDir,
+                templates: answers.sharedApi
+                    ? [types_js_1.INFRA_FILE]
+                    : apps.map((app) => (0, types_js_1.serviceTemplatePath)(app.name)),
+                compatibleRuntimes: [(0, types_js_1.lambdaRuntime)(answers.runtime)],
+                attachAllFunctions: layerAttachedTo.length === applications.flatMap((a) => a.functions).length,
+                attachedTo: layerAttachedTo,
+            }
+            : { enabled: false, path: `${types_js_1.SRC_DIR}/shared` },
+        environments: preserved.environments ?? {
+            default: environments_js_1.DEFAULT_ENVIRONMENT,
+            list: {
+                [environments_js_1.DEFAULT_ENVIRONMENT]: {
+                    stackName: (0, environments_js_1.stackNameFor)(answers.name, environments_js_1.DEFAULT_ENVIRONMENT),
+                },
+            },
+        },
+        applications,
+        services,
+        structure: {
+            directories,
+            files: [...generatedFiles, "slskit.json"].sort(),
+        },
+    };
+}

package/dist/commands/init/prompts.d.ts

@@ -0,0 +1,6 @@
+import type { InitAnswers, InitOptions, MemorySize, RuntimeId } from "./types.js";
+export declare const RUNTIME_ALIASES: Record<string, RuntimeId>;
+export declare function parseAlias<T extends string>(value: string | undefined, aliases: Record<string, T>, label: string): T | undefined;
+export declare function parseMemory(value: string | number | undefined): MemorySize | undefined;
+export declare function memoryLabel(size: MemorySize): string;
+export declare function collectAnswers(options: InitOptions): Promise<InitAnswers>;

package/dist/commands/init/prompts.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_ALIASES = void 0;
+exports.parseAlias = parseAlias;
+exports.parseMemory = parseMemory;
+exports.memoryLabel = memoryLabel;
+exports.collectAnswers = collectAnswers;
+const errors_js_1 = require("../../core/errors.js");
+const types_js_1 = require("./types.js");
+exports.RUNTIME_ALIASES = {
+    typescript: "typescript",
+    ts: "typescript",
+    "node-ts": "typescript",
+    javascript: "javascript",
+    js: "javascript",
+    node: "javascript",
+    nodejs: "javascript",
+    python: "python",
+    py: "python",
+    python3: "python",
+};
+const DATABASE_ALIASES = {
+    none: "none",
+    skip: "none",
+    no: "none",
+    prisma: "prisma",
+    mongoose: "mongoose",
+    mongo: "mongoose",
+    mongodb: "mongoose",
+    dynamodb: "dynamodb",
+    dynamo: "dynamodb",
+    documentclient: "dynamodb",
+};
+function parseAlias(value, aliases, label) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = aliases[value.trim().toLowerCase()];
+    if (!parsed) {
+        throw new errors_js_1.CliError(`Unknown ${label} "${value}". Expected ${Object.keys(aliases).join(", ")}.`);
+    }
+    return parsed;
+}
+function parseYesNo(value, label) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    const normalized = String(value).trim().toLowerCase();
+    if (["yes", "y", "true", "1"].includes(normalized)) {
+        return true;
+    }
+    if (["no", "n", "false", "0"].includes(normalized)) {
+        return false;
+    }
+    throw new errors_js_1.CliError(`${label} must be yes or no.`);
+}
+function parseMemory(value) {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    const parsed = Number(String(value).replace(/mb$/i, "").trim());
+    if (!types_js_1.MEMORY_SIZES.includes(parsed)) {
+        throw new errors_js_1.CliError(`Unknown memory size "${value}". Choose ${types_js_1.MEMORY_SIZES.join(", ")}.`);
+    }
+    return parsed;
+}
+function memoryLabel(size) {
+    if (size % 1024 === 0) {
+        return `${size} MB (${size / 1024} GB)`;
+    }
+    return `${size} MB`;
+}
+async function collectAnswers(options) {
+    let name = options.name?.trim();
+    let runtime = parseAlias(options.runtime, exports.RUNTIME_ALIASES, "runtime");
+    let database = parseAlias(options.database, DATABASE_ALIASES, "database");
+    let apiGateway = parseYesNo(options.apiGateway, "--api-gateway");
+    let sharedApi = parseYesNo(options.sharedApi, "--shared-api");
+    let layer = parseYesNo(options.layer, "--layer");
+    let memorySize = parseMemory(options.memory);
+    const needsPrompt = !name ||
+        !runtime ||
+        !database ||
+        apiGateway === undefined ||
+        layer === undefined ||
+        memorySize === undefined;
+    if (needsPrompt && !process.stdin.isTTY) {
+        throw new errors_js_1.CliError("Non-interactive init needs --name, --runtime, --database, --api-gateway, --layer, and --memory.");
+    }
+    if (needsPrompt) {
+        const { input, select, confirm } = await import("@inquirer/prompts");
+        name ?? (name = await input({
+            message: "Project Name:",
+            default: "my-lambda-app",
+            required: true,
+        }));
+        runtime ?? (runtime = await select({
+            message: "Runtime:",
+            choices: [
+                { name: "TypeScript (Node.js)", value: "typescript" },
+                { name: "JavaScript (Node.js)", value: "javascript" },
+                { name: "Python", value: "python" },
+            ],
+        }));
+        database ?? (database = await select({
+            message: "Database / ORM (Optional):",
+            choices: [
+                { name: "None", value: "none" },
+                { name: "Prisma", value: "prisma" },
+                { name: "Mongoose", value: "mongoose" },
+                { name: "DynamoDB DocumentClient", value: "dynamodb" },
+            ],
+        }));
+        apiGateway ?? (apiGateway = await confirm({
+            message: "API Gateway? Expose your functions over HTTP",
+            default: true,
+        }));
+        if (apiGateway) {
+            // Defaults to no: a root stack nesting one template per service is the layout
+            // that keeps working as a project grows past CloudFormation's 500-resource cap.
+            sharedApi ?? (sharedApi = await confirm({
+                message: "One shared API Gateway for every function? (no = a template per service)",
+                default: false,
+            }));
+        }
+        layer ?? (layer = await confirm({
+            message: "Common Lambda layer? Use shared/ and attach it to every function",
+            default: true,
+        }));
+        memorySize ?? (memorySize = await select({
+            message: "Function memory size:",
+            choices: types_js_1.MEMORY_SIZES.map((size) => ({
+                name: memoryLabel(size),
+                value: size,
+            })),
+        }));
+    }
+    const projectName = name?.trim();
+    if (!projectName) {
+        throw new errors_js_1.CliError("Project name is required.");
+    }
+    return {
+        name: projectName,
+        runtime: runtime,
+        database: database,
+        apiGateway: Boolean(apiGateway),
+        sharedApi: Boolean(apiGateway) && sharedApi === true,
+        layer: Boolean(layer),
+        memorySize: memorySize,
+        force: Boolean(options.force),
+    };
+}

package/dist/commands/init/scaffold.d.ts

@@ -0,0 +1,7 @@
+import type { InitAnswers } from "./types.js";
+export declare function resolveProjectRoot(cwd: string, name: string): {
+    root: string;
+    folderName: string;
+};
+export declare function ensureProjectRoot(root: string, force: boolean): void;
+export declare function scaffoldProject(answers: InitAnswers, cwd?: string): Promise<string>;

package/dist/commands/init/scaffold.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectRoot = resolveProjectRoot;
+exports.ensureProjectRoot = ensureProjectRoot;
+exports.scaffoldProject = scaffoldProject;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_js_1 = require("../../core/errors.js");
+const logger_js_1 = require("../../core/logger.js");
+const content_js_1 = require("./content.js");
+function run(cwd, command, args, env) {
+    logger_js_1.logger.info(`> ${command} ${args.join(" ")}`);
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd,
+        stdio: "inherit",
+        env: env ? { ...process.env, ...env } : process.env,
+        shell: process.platform === "win32",
+    });
+    if (result.error) {
+        throw new errors_js_1.CliError(`Failed to run ${command}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new errors_js_1.CliError(`${command} exited with code ${result.status ?? 1}`);
+    }
+}
+// An environment file holds real credentials, so --force must never clobber one.
+const isEnvironmentFile = (relativePath) => relativePath.startsWith(".env");
+function writeFiles(root, files) {
+    for (const [relativePath, contents] of Object.entries(files)) {
+        const fullPath = node_path_1.default.join(root, relativePath);
+        if (isEnvironmentFile(relativePath) && node_fs_1.default.existsSync(fullPath)) {
+            logger_js_1.logger.info(`Kept existing ${relativePath} rather than overwriting its values`);
+            continue;
+        }
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
+        node_fs_1.default.writeFileSync(fullPath, contents);
+    }
+}
+function resolveProjectRoot(cwd, name) {
+    if (name === ".") {
+        return { root: cwd, folderName: node_path_1.default.basename(cwd) };
+    }
+    return { root: node_path_1.default.join(cwd, name), folderName: name };
+}
+function ensureProjectRoot(root, force) {
+    if (!node_fs_1.default.existsSync(root)) {
+        node_fs_1.default.mkdirSync(root, { recursive: true });
+        return;
+    }
+    const entries = node_fs_1.default.readdirSync(root).filter((entry) => entry !== ".git");
+    if (entries.length === 0 || force) {
+        return;
+    }
+    throw new errors_js_1.CliError(`Directory already exists and is not empty: ${root}. Re-run with --force to overwrite generated files.`);
+}
+async function scaffoldProject(answers, cwd = process.cwd()) {
+    const { root, folderName } = resolveProjectRoot(cwd, answers.name);
+    const project = { ...answers, name: folderName };
+    ensureProjectRoot(root, project.force);
+    writeFiles(root, (0, content_js_1.buildFileMap)(project));
+    const pkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(root, "package.json"), "utf8"));
+    const hasNpmDeps = Object.keys(pkg.dependencies ?? {}).length > 0 ||
+        Object.keys(pkg.devDependencies ?? {}).length > 0;
+    if (hasNpmDeps) {
+        logger_js_1.logger.info("\nInstalling npm dependencies...");
+        run(root, "npm", ["install"]);
+    }
+    if (project.runtime === "python" && node_fs_1.default.existsSync(node_path_1.default.join(root, "requirements.txt"))) {
+        logger_js_1.logger.info("\nCreating Python venv and installing requirements...");
+        run(root, "python3", ["-m", "venv", ".venv"]);
+        const pip = node_path_1.default.join(root, ".venv", "bin", "pip");
+        run(root, pip, ["install", "-r", "requirements.txt"]);
+    }
+    if (project.database === "prisma" && project.runtime !== "python") {
+        logger_js_1.logger.info("\nGenerating Prisma client...");
+        run(root, "npx", ["prisma", "generate"], {
+            DATABASE_URL: process.env.DATABASE_URL ?? "postgresql://user:password@localhost:5432/app",
+        });
+    }
+    return root;
+}

package/dist/commands/init/templates/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { InitAnswers } from "../types.js";
+export declare function pascal(value: string): string;
+export declare function envParameterName(key: string): string;
+export declare function loggerExt(runtime: InitAnswers["runtime"]): "ts" | "js" | "py";
+export declare function nodeLayerImport(moduleName: string): string;
+export declare function dynamoTableName(appName: string): {
+    resource: string;
+    table: string;
+};

package/dist/commands/init/templates/helpers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascal = pascal;
+exports.envParameterName = envParameterName;
+exports.loggerExt = loggerExt;
+exports.nodeLayerImport = nodeLayerImport;
+exports.dynamoTableName = dynamoTableName;
+function pascal(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+// CloudFormation parameter names are alphanumeric only, so LOG_LEVEL becomes
+// EnvLogLevel. The Env prefix keeps stage variables from ever colliding with the
+// database parameters the templates already declare.
+function envParameterName(key) {
+    return `Env${key
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean)
+        .map(pascal)
+        .join("")}`;
+}
+function loggerExt(runtime) {
+    if (runtime === "python") {
+        return "py";
+    }
+    return runtime === "typescript" ? "ts" : "js";
+}
+function nodeLayerImport(moduleName) {
+    return `/opt/nodejs/${moduleName}`;
+}
+// "auth"/"product" keep their original table names for backward compatibility with
+// projects already deployed against them; any app added later gets a name derived
+// from the app itself.
+function dynamoTableName(appName) {
+    if (appName === "auth") {
+        return { resource: "UsersTable", table: "users" };
+    }
+    if (appName === "product") {
+        return { resource: "ProductsTable", table: "products" };
+    }
+    return { resource: `${pascal(appName)}Table`, table: appName };
+}

package/dist/commands/init/templates/node.d.ts

@@ -0,0 +1,4 @@
+import type { InitAnswers, ServiceFunction } from "../types.js";
+export declare function nodeService(answers: InitAnswers, fn: ServiceFunction, typed: boolean): string;
+export declare function standaloneNodeService(fn: ServiceFunction, typed: boolean): string;
+export declare function nodeHandler(answers: InitAnswers, appName: string, fn: ServiceFunction, typed: boolean): string;