slskit-cli 1.0.0

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeService = nodeService;
+exports.standaloneNodeService = standaloneNodeService;
+exports.nodeHandler = nodeHandler;
+const helpers_js_1 = require("./helpers.js");
+function nodeSharedImports(answers) {
+    const loggerFrom = answers.layer
+        ? (0, helpers_js_1.nodeLayerImport)("logger")
+        : "../../shared/logger";
+    // db is never in the layer, so it is always imported by relative path and bundled.
+    const dbFrom = "../../shared/db";
+    const lines = [`import { logger } from "${loggerFrom}";`];
+    if (answers.database === "prisma") {
+        lines.push(`import { prisma } from "${dbFrom}";`);
+    }
+    else if (answers.database === "mongoose") {
+        lines.push(`import { connectDb } from "${dbFrom}";`);
+    }
+    else if (answers.database === "dynamodb") {
+        lines.push(`import { docClient } from "${dbFrom}";`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function nodeService(answers, fn, typed) {
+    const dbSetup = answers.database === "mongoose"
+        ? "  await connectDb();\n"
+        : answers.database === "prisma"
+            ? "  void prisma;\n"
+            : answers.database === "dynamodb"
+                ? "  void docClient;\n"
+                : "";
+    const eventType = typed
+        ? `import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";\n`
+        : "";
+    const signature = typed
+        ? `export async function ${fn.name}(
+  event: APIGatewayProxyEvent
+): Promise<APIGatewayProxyResult> {`
+        : `export async function ${fn.name}(event) {`;
+    return `${eventType}${nodeSharedImports(answers)}
+${signature}
+${dbSetup}  logger.info("${fn.name} invoked");
+  const payload = event.body ? JSON.parse(event.body) : {};
+
+  return {
+    statusCode: 200,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      message: "${fn.name}",
+      input: payload,
+    }),
+  };
+}
+`;
+}
+// Used when a function's runtime family differs from the project's: it can't attach
+// the project's layer or import its db client (built for the other family), so it
+// ships as a plain, self-contained handler instead.
+function standaloneNodeService(fn, typed) {
+    const eventType = typed
+        ? `import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";\n\n`
+        : "";
+    const signature = typed
+        ? `export async function ${fn.name}(
+  event: APIGatewayProxyEvent
+): Promise<APIGatewayProxyResult> {`
+        : `export async function ${fn.name}(event) {`;
+    return `${eventType}${signature}
+  console.log(JSON.stringify({ level: "info", message: "${fn.name} invoked" }));
+  const payload = event.body ? JSON.parse(event.body) : {};
+
+  return {
+    statusCode: 200,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      message: "${fn.name}",
+      input: payload,
+    }),
+  };
+}
+`;
+}
+function nodeHandler(answers, appName, fn, typed) {
+    const eventType = typed
+        ? `import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";\n`
+        : "";
+    const signature = typed
+        ? `export async function handler(
+  event: APIGatewayProxyEvent
+): Promise<APIGatewayProxyResult> {`
+        : `export async function handler(event) {`;
+    return `${eventType}import { ${fn.name} } from "../../../services/${appName}/${fn.name}";
+
+${signature}
+  return ${fn.name}(event);
+}
+`;
+}

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

@@ -0,0 +1,8 @@
+import type { InitAnswers } from "../types.js";
+export declare function gitignore(runtime: InitAnswers["runtime"]): string;
+export declare function readme(answers: InitAnswers): string;
+export declare function packageJson(answers: InitAnswers): string;
+export declare function tsconfig(answers: InitAnswers): string;
+export declare function databaseSeedVariables(database: InitAnswers["database"]): string | undefined;
+export declare function environmentDotenv(environment: string, database: InitAnswers["database"]): string;
+export declare function requirementsTxt(answers: InitAnswers): string;

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

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitignore = gitignore;
+exports.readme = readme;
+exports.packageJson = packageJson;
+exports.tsconfig = tsconfig;
+exports.databaseSeedVariables = databaseSeedVariables;
+exports.environmentDotenv = environmentDotenv;
+exports.requirementsTxt = requirementsTxt;
+const environments_js_1 = require("../../../core/environments.js");
+const types_js_1 = require("../types.js");
+const helpers_js_1 = require("./helpers.js");
+function gitignore(runtime) {
+    const lines = [
+        "node_modules/",
+        "dist/",
+        ".aws-sam/",
+        ".slskit-local.yaml",
+        ".env",
+        ".env.*",
+        ".DS_Store",
+        "*.log",
+    ];
+    if (runtime === "python") {
+        lines.push(".venv/", "__pycache__/", "*.pyc");
+    }
+    return `${lines.join("\n")}\n`;
+}
+function prismaSteps(answers) {
+    if (answers.database !== "prisma" || answers.runtime === "python") {
+        return "";
+    }
+    return `
+## Prisma
+
+Point \`DATABASE_URL\` in \`.env.${environments_js_1.DEFAULT_ENVIRONMENT}\` at your database, then:
+
+\`\`\`bash
+npm run prisma:migrate    # create and apply a migration (development)
+npm run prisma:generate   # regenerate the client after editing schema.prisma
+npm run prisma:studio     # browse the data
+\`\`\`
+
+Deployments apply already-created migrations instead:
+
+\`\`\`bash
+npm run prisma:deploy
+\`\`\`
+
+Those scripts read \`.env.${environments_js_1.DEFAULT_ENVIRONMENT}\`. Run them against another
+environment by naming its file:
+
+\`\`\`bash
+npx dotenv -e .env.production -- npx prisma migrate deploy
+\`\`\`
+`;
+}
+function readme(answers) {
+    const layerRuntime = answers.layer && answers.runtime === "typescript" ? "javascript" : answers.runtime;
+    const sharedFiles = [
+        `│   │   └── logger.${(0, helpers_js_1.loggerExt)(layerRuntime)}`,
+        ...(answers.database !== "none" ? ["│   │   └── db." + (0, types_js_1.sourceExt)(answers.runtime)] : []),
+    ];
+    const nextSteps = ["```bash", "sam build", "sam deploy --guided", "```"];
+    return `# ${answers.name}
+
+Generated by **slskit init**.
+
+- Runtime: ${answers.runtime}
+- Framework: AWS SAM
+- Database: ${answers.database}
+- API Gateway: ${answers.apiGateway
+        ? "yes (each service owns an HTTP API in its own template)"
+        : "no"}
+- Common layer: ${answers.layer ? "yes (src/shared attached to every function)" : "no"}
+- Function memory: ${answers.memorySize} MB
+
+See \`slskit.json\` for the full project graph.
+
+## Layout
+
+Every service owns a \`${types_js_1.INFRA_FILE}\` next to its handlers, so services can be
+deployed one at a time. The root \`template.yaml\` pulls them all together.
+
+\`\`\`text
+${answers.name}/
+├── ${types_js_1.SRC_DIR}/
+│   ├── functions/
+│   │   ├── auth/
+│   │   │   ├── ${types_js_1.INFRA_FILE}
+│   │   │   ├── login/handler.${(0, types_js_1.sourceExt)(answers.runtime)}
+│   │   │   └── register/handler.${(0, types_js_1.sourceExt)(answers.runtime)}
+│   │   └── product/
+│   │       ├── ${types_js_1.INFRA_FILE}
+│   │       ├── getProducts/handler.${(0, types_js_1.sourceExt)(answers.runtime)}
+│   │       └── createProduct/handler.${(0, types_js_1.sourceExt)(answers.runtime)}
+│   ├── services/
+│   │   ├── auth/login.${(0, types_js_1.sourceExt)(answers.runtime)}
+│   │   └── product/getProducts.${(0, types_js_1.sourceExt)(answers.runtime)}
+│   └── shared/
+${sharedFiles.join("\n")}
+├── template.yaml         (root stack)
+├── .env.${environments_js_1.DEFAULT_ENVIRONMENT}              (the "${environments_js_1.DEFAULT_ENVIRONMENT}" environment's values, gitignored)
+├── package.json
+├── slskit.json
+└── README.md
+\`\`\`
+
+Each function delegates to a matching service module: \`${types_js_1.SRC_DIR}/functions/auth/login\`
+calls \`${types_js_1.SRC_DIR}/services/auth/login\`.
+
+## Environments
+
+The project starts with one environment, \`${environments_js_1.DEFAULT_ENVIRONMENT}\`, and its values live in
+\`.env.${environments_js_1.DEFAULT_ENVIRONMENT}\`. Add more as you need them -- each one gets its own file,
+its own CloudFormation stack, and its own \`${environments_js_1.APP_ENVIRONMENT_KEY}\`.
+
+\`\`\`bash
+slskit env list
+slskit env add production --profile prod-admin --region eu-west-2
+slskit env set LOG_LEVEL=debug
+\`\`\`
+
+## Next steps
+
+${nextSteps.join("\n")}
+${prismaSteps(answers)}`;
+}
+function packageJson(answers) {
+    const isNode = answers.runtime !== "python";
+    const dependencies = {};
+    const devDependencies = {};
+    if (isNode) {
+        if (answers.runtime === "typescript") {
+            devDependencies.typescript = "^5.7.2";
+            devDependencies["@types/node"] = "^22.10.2";
+            devDependencies["@types/aws-lambda"] = "^8.10.145";
+        }
+        if (answers.database === "prisma") {
+            dependencies["@prisma/client"] = "^6.5.0";
+            devDependencies.prisma = "^6.5.0";
+            // The Prisma CLI only reads ".env"; this points it at the environment file instead.
+            devDependencies["dotenv-cli"] = "^8.0.0";
+        }
+        if (answers.database === "mongoose") {
+            dependencies.mongoose = "^8.12.1";
+        }
+        if (answers.database === "dynamodb") {
+            dependencies["@aws-sdk/client-dynamodb"] = "^3.750.0";
+            dependencies["@aws-sdk/lib-dynamodb"] = "^3.750.0";
+        }
+        // sam build stages the project with `npm install --omit=dev`, so esbuild must be a regular dependency.
+        dependencies.esbuild = "^0.25.0";
+    }
+    const scripts = {
+        build: "sam build",
+        deploy: "sam deploy --guided",
+    };
+    if (answers.runtime === "typescript") {
+        scripts.typecheck = "tsc --noEmit";
+    }
+    if (answers.database === "prisma" && isNode) {
+        const withEnv = `dotenv -e .env.${environments_js_1.DEFAULT_ENVIRONMENT} --`;
+        scripts["prisma:generate"] = `${withEnv} prisma generate`;
+        scripts["prisma:migrate"] = `${withEnv} prisma migrate dev`;
+        // migrate dev is interactive and dev-only; deployments need migrate deploy.
+        scripts["prisma:deploy"] = `${withEnv} prisma migrate deploy`;
+        scripts["prisma:studio"] = `${withEnv} prisma studio`;
+    }
+    return `${JSON.stringify({
+        name: answers.name,
+        version: "0.1.0",
+        private: true,
+        description: `${answers.name} AWS SAM app generated by slskit`,
+        scripts,
+        dependencies,
+        devDependencies,
+    }, null, 2)}\n`;
+}
+function tsconfig(answers) {
+    const compilerOptions = {
+        target: "ES2020",
+        module: "node16",
+        moduleResolution: "node16",
+        lib: ["ES2020"],
+        strict: true,
+        esModuleInterop: true,
+        forceConsistentCasingInFileNames: true,
+        skipLibCheck: true,
+        types: ["node"],
+        outDir: "dist",
+        rootDir: types_js_1.SRC_DIR,
+    };
+    if (answers.layer && answers.runtime !== "python") {
+        compilerOptions.paths = {
+            "/opt/nodejs/*": [`./${types_js_1.SRC_DIR}/shared/nodejs/*`],
+        };
+    }
+    // "sam build" copies the whole project root -- tsconfig.json included -- into
+    // .aws-sam/build/<Function>/, and wipes it on the next build. Without an explicit
+    // exclude an editor loads those copies as extra TypeScript programs and then
+    // reports their vanished files as "not found" against this include pattern.
+    return `${JSON.stringify({
+        compilerOptions,
+        include: [`${types_js_1.SRC_DIR}/**/*.ts`],
+        exclude: ["node_modules", "dist", ".aws-sam", ".venv"],
+    }, null, 2)}\n`;
+}
+// The connection string a database needs, seeded into the first environment file as
+// an ordinary stage variable. DynamoDB is absent on purpose: the templates create
+// those tables and hardcode their names, so they are not stage configuration.
+function databaseSeedVariables(database) {
+    if (database === "prisma") {
+        return `DATABASE_URL="postgresql://user:password@localhost:5432/app"\n`;
+    }
+    if (database === "mongoose") {
+        return `MONGODB_URI="mongodb://127.0.0.1:27017/app"\n`;
+    }
+    return undefined;
+}
+// Matches the format "slskit env set" writes, so the two never fight over the file.
+function environmentDotenv(environment, database) {
+    const lines = [`${environments_js_1.APP_ENVIRONMENT_KEY}=${environment}`];
+    const dbExample = databaseSeedVariables(database);
+    if (dbExample) {
+        lines.push(...dbExample.trimEnd().split("\n"));
+    }
+    return `# Values for the "${environment}" environment. Never commit this file.\n${lines.join("\n")}\n`;
+}
+function requirementsTxt(answers) {
+    const lines = ["boto3>=1.35.0"];
+    if (answers.database === "prisma") {
+        lines.push("prisma>=0.15.0");
+    }
+    if (answers.database === "mongoose") {
+        lines.push("pymongo>=4.10.0");
+    }
+    return `${lines.join("\n")}\n`;
+}

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

@@ -0,0 +1,4 @@
+import type { InitAnswers, ServiceFunction } from "../types.js";
+export declare function pythonService(answers: InitAnswers, fn: ServiceFunction): string;
+export declare function standalonePythonService(fn: ServiceFunction): string;
+export declare function pythonHandler(appName: string, fn: ServiceFunction): string;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonService = pythonService;
+exports.standalonePythonService = standalonePythonService;
+exports.pythonHandler = pythonHandler;
+const types_js_1 = require("../types.js");
+function pythonService(answers, fn) {
+    // The layer lands on sys.path as /opt/python, so its modules are imported bare.
+    // Everything else is packaged from the project root, hence the src. prefix.
+    const loggerImport = answers.layer
+        ? "from logger import logger"
+        : `from ${types_js_1.SRC_DIR}.shared.logger import logger`;
+    // db is never in the layer, so it is always imported from the packaged source tree.
+    const dbImport = answers.database === "none"
+        ? ""
+        : answers.database === "dynamodb"
+            ? `from ${types_js_1.SRC_DIR}.shared.db import users_table, products_table\n`
+            : `from ${types_js_1.SRC_DIR}.shared.db import connect_db\n`;
+    const dbSetup = answers.database === "none"
+        ? ""
+        : answers.database === "dynamodb"
+            ? "    _ = (users_table, products_table)\n"
+            : "    _ = connect_db\n";
+    return `import json
+${loggerImport}
+${dbImport}
+def ${fn.name}(event, context):
+${dbSetup}    logger.info("${fn.name} invoked")
+    body = event.get("body")
+    payload = json.loads(body) if body else {}
+
+    return {
+        "statusCode": 200,
+        "headers": {"Content-Type": "application/json"},
+        "body": json.dumps({"message": "${fn.name}", "input": payload}),
+    }
+`;
+}
+// Used when a function's runtime family differs from the project's: it can't attach
+// the project's layer or import its db client (built for the other family), so it
+// ships as a plain, self-contained handler instead.
+function standalonePythonService(fn) {
+    return `import json
+
+
+def ${fn.name}(event, context):
+    print(json.dumps({"level": "info", "message": "${fn.name} invoked"}))
+    body = event.get("body")
+    payload = json.loads(body) if body else {}
+
+    return {
+        "statusCode": 200,
+        "headers": {"Content-Type": "application/json"},
+        "body": json.dumps({"message": "${fn.name}", "input": payload}),
+    }
+`;
+}
+function pythonHandler(appName, fn) {
+    return `from ${types_js_1.SRC_DIR}.services.${appName}.${fn.name} import ${fn.name}
+
+
+def handler(event, context):
+    return ${fn.name}(event, context)
+`;
+}

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

@@ -0,0 +1,4 @@
+import type { InitAnswers, ServiceDef } from "../types.js";
+export declare function samServiceTemplate(answers: InitAnswers, service: ServiceDef, envKeys?: string[]): string;
+export declare function samFlatTemplate(answers: InitAnswers, apps: ServiceDef[], envKeys?: string[]): string;
+export declare function samRootTemplate(answers: InitAnswers, apps: ServiceDef[], envKeys?: string[]): string;