slskit-cli 1.0.0

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

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.samServiceTemplate = samServiceTemplate;
+exports.samFlatTemplate = samFlatTemplate;
+exports.samRootTemplate = samRootTemplate;
+const environments_js_1 = require("../../../core/environments.js");
+const types_js_1 = require("../types.js");
+const helpers_js_1 = require("./helpers.js");
+// DATABASE_URL and MONGODB_URI are not special-cased: init seeds them into
+// .env.<environment> like any other variable, so they arrive through envKeys and are
+// overridable per stage. Only the DynamoDB table names stay literal -- the templates
+// create those tables, so they are not stage configuration.
+function databaseVariables(database) {
+    if (database === "dynamodb") {
+        return ["USERS_TABLE: users", "PRODUCTS_TABLE: products"];
+    }
+    return [];
+}
+// Stage variables are wired to parameters rather than literals so one template can
+// serve every stage: the deploy supplies the values as --parameter-overrides.
+function environmentYaml(database, envKeys, indent) {
+    const variables = [
+        `${environments_js_1.APP_ENVIRONMENT_KEY}: !Ref ${environments_js_1.APP_ENVIRONMENT_PARAM}`,
+        ...databaseVariables(database),
+        ...envKeys.map((key) => `${key}: !Ref ${(0, helpers_js_1.envParameterName)(key)}`),
+    ];
+    const body = variables.map((line) => `${indent}    ${line}`).join("\n");
+    return `${indent}Environment:\n${indent}  Variables:\n${body}\n`;
+}
+function stageParameterNames(envKeys) {
+    return envKeys.map(helpers_js_1.envParameterName);
+}
+function appEnvironmentParameter() {
+    return `  ${environments_js_1.APP_ENVIRONMENT_PARAM}:
+    Type: String
+    Default: ${environments_js_1.DEFAULT_ENVIRONMENT}
+    Description: Deployment environment; every stage-scoped resource name is built from it`;
+}
+function samParameters(envKeys, extra = []) {
+    const params = [appEnvironmentParameter(), ...extra];
+    // Every stage variable defaults to empty, so a stage that does not set one can
+    // still deploy from the same template without supplying an override. NoEcho is
+    // unconditional: any of them may hold a connection string or an API key, and
+    // nothing here reads a parameter value back out of CloudFormation.
+    for (const key of envKeys) {
+        params.push(`  ${(0, helpers_js_1.envParameterName)(key)}:
+    Type: String
+    Default: ""
+    NoEcho: true
+    Description: ${key} environment variable`);
+    }
+    return `Parameters:\n${params.join("\n")}\n\n`;
+}
+function samHttpApiResource() {
+    return `  HttpApi:
+    Type: AWS::Serverless::HttpApi
+    Properties:
+      StageName: $default
+      CorsConfiguration:
+        AllowMethods:
+          - GET
+          - POST
+          - OPTIONS
+        AllowHeaders:
+          - "*"
+        AllowOrigins:
+          - "*"
+
+`;
+}
+// Like CodeUri, this is relative to the template that declares it, not to the API mode.
+function samSharedLayerResource(answers, site) {
+    const runtime = (0, types_js_1.lambdaRuntime)(answers.runtime);
+    const buildMethod = answers.runtime === "python" ? "python3.12" : "nodejs20.x";
+    const layerDir = answers.runtime === "python" ? "shared/python" : "shared/nodejs";
+    const contentUri = site === "root" ? `${types_js_1.SRC_DIR}/${layerDir}` : `../${types_js_1.SRC_DIR}/${layerDir}`;
+    return `  SharedLayer:
+    Type: AWS::Serverless::LayerVersion
+    Properties:
+      LayerName: !Sub "\${AWS::StackName}-shared"
+      Description: Shared utilities attached to every function
+      ContentUri: ${contentUri}
+      CompatibleRuntimes:
+        - ${runtime}
+      RetentionPolicy: Retain
+    Metadata:
+      BuildMethod: ${buildMethod}
+
+`;
+}
+function samDynamoResources(service) {
+    const { resource, table } = (0, helpers_js_1.dynamoTableName)(service.name);
+    return `
+  ${resource}:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      TableName: ${table}
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+        - AttributeName: id
+          AttributeType: S
+      KeySchema:
+        - AttributeName: id
+          KeyType: HASH
+`;
+}
+function samPolicies(database, service) {
+    if (database !== "dynamodb") {
+        return "";
+    }
+    const { resource } = (0, helpers_js_1.dynamoTableName)(service.name);
+    return `      Policies:
+        - DynamoDBCrudPolicy:
+            TableName: !Ref ${resource}
+`;
+}
+function samHttpEvent(fn) {
+    return `      Events:
+        ${(0, helpers_js_1.pascal)(fn.name)}Api:
+          Type: HttpApi
+          Properties:
+            ApiId: !Ref HttpApi
+            Path: ${fn.httpPath}
+            Method: ${fn.method}
+`;
+}
+function samFunctionName(answers, fn) {
+    return `      FunctionName: !Sub "${answers.name}-\${${environments_js_1.APP_ENVIRONMENT_PARAM}}-${fn.name}"\n`;
+}
+function codeUriFor(site) {
+    return site === "root" ? "./" : "../";
+}
+// With one shared API Gateway the API lives in the root stack, which SAM's HttpApi
+// event cannot reach ("ApiId must be a valid reference to an AWS::Serverless::HttpApi
+// resource in same template"). Plain API Gateway v2 resources have no such rule, so
+// the routes are declared directly against the id the root passes down.
+const SHARED_API_PARAM = "HttpApiId";
+function samRawRoute(fn) {
+    const name = (0, helpers_js_1.pascal)(fn.name);
+    return `
+  ${name}Integration:
+    Type: AWS::ApiGatewayV2::Integration
+    Properties:
+      ApiId: !Ref ${SHARED_API_PARAM}
+      IntegrationType: AWS_PROXY
+      IntegrationUri: !GetAtt ${name}Function.Arn
+      PayloadFormatVersion: "2.0"
+
+  ${name}Route:
+    Type: AWS::ApiGatewayV2::Route
+    Properties:
+      ApiId: !Ref ${SHARED_API_PARAM}
+      RouteKey: "${fn.method} ${fn.httpPath}"
+      Target: !Sub "integrations/\${${name}Integration}"
+
+  ${name}Permission:
+    Type: AWS::Lambda::Permission
+    Properties:
+      Action: lambda:InvokeFunction
+      FunctionName: !Ref ${name}Function
+      Principal: apigateway.amazonaws.com
+      SourceArn: !Sub "arn:\${AWS::Partition}:execute-api:\${AWS::Region}:\${AWS::AccountId}:\${${SHARED_API_PARAM}}/*/*"
+`;
+}
+function sharedApiParameter() {
+    return `  ${SHARED_API_PARAM}:
+    Type: String
+    Description: The project's shared HTTP API; this service attaches its routes to it`;
+}
+// The one API every service hangs its routes off. Declared with plain API Gateway v2
+// resources rather than AWS::Serverless::HttpApi so that nested stacks can reference it.
+function samSharedApiResources(answers) {
+    return `  SharedHttpApi:
+    Type: AWS::ApiGatewayV2::Api
+    Properties:
+      Name: !Sub "${answers.name}-\${${environments_js_1.APP_ENVIRONMENT_PARAM}}"
+      ProtocolType: HTTP
+      CorsConfiguration:
+        AllowMethods:
+          - GET
+          - POST
+          - OPTIONS
+        AllowHeaders:
+          - "*"
+        AllowOrigins:
+          - "*"
+
+  SharedHttpApiStage:
+    Type: AWS::ApiGatewayV2::Stage
+    Properties:
+      ApiId: !Ref SharedHttpApi
+      StageName: $default
+      AutoDeploy: true
+
+`;
+}
+function samFunction(answers, service, fn, envKeys, site) {
+    const fnRuntime = fn.runtime ?? answers.runtime;
+    // A function in a different runtime family than the project can't attach the
+    // project's layer or import its db client, so it runs standalone instead.
+    const sameFamily = (0, types_js_1.sameRuntimeFamily)(fnRuntime, answers.runtime);
+    const useLayer = answers.layer && sameFamily;
+    const database = sameFamily ? answers.database : "none";
+    const memorySize = fn.memorySize ?? answers.memorySize;
+    const resource = `${(0, helpers_js_1.pascal)(fn.name)}Function`;
+    const functionName = samFunctionName(answers, fn);
+    const env = environmentYaml(database, envKeys, "      ");
+    const policies = samPolicies(database, service);
+    const runtime = (0, types_js_1.lambdaRuntime)(fnRuntime);
+    const layers = useLayer ? `      Layers:\n        - !Ref SharedLayer\n` : "";
+    // Routes are SAM events when the API is in this template, and separate API Gateway
+    // resources when it lives in the root stack.
+    const events = answers.apiGateway && !(answers.sharedApi && site === "service")
+        ? samHttpEvent(fn)
+        : "";
+    // CodeUri is the project root: SAM stages it and runs npm install / pip install there,
+    // so package.json and requirements.txt must be inside it.
+    if (fnRuntime === "python") {
+        return `  ${resource}:
+    Type: AWS::Serverless::Function
+    Properties:
+${functionName}      CodeUri: ${codeUriFor(site)}
+      Handler: ${types_js_1.SRC_DIR}.functions.${service.name}.${fn.name}.handler.handler
+      Runtime: ${runtime}
+      MemorySize: ${memorySize}
+${env}${policies}${layers}${events}`;
+    }
+    const entryExt = fnRuntime === "typescript" ? "ts" : "js";
+    const entry = `${types_js_1.SRC_DIR}/functions/${service.name}/${fn.name}/handler.${entryExt}`;
+    const handlerPath = `${entry.replace(/\.(ts|js)$/, "")}.handler`;
+    const externals = useLayer
+        ? `        External:
+          - "/opt/nodejs/*"
+`
+        : "";
+    return `  ${resource}:
+    Type: AWS::Serverless::Function
+    Properties:
+${functionName}      CodeUri: ${codeUriFor(site)}
+      Handler: ${handlerPath}
+      Runtime: ${runtime}
+      MemorySize: ${memorySize}
+${env}${policies}${layers}${events}    Metadata:
+      BuildMethod: esbuild
+      BuildProperties:
+        Format: cjs
+        Minify: false
+        Target: es2020
+        Sourcemap: true
+        EntryPoints:
+          - ${entry}
+${externals}`;
+}
+// One stack per service, nested by the root. With per-service APIs the stack owns its
+// own HTTP API; with a shared one it takes the API's id from the root and attaches
+// routes to it.
+function samServiceTemplate(answers, service, envKeys = []) {
+    const shared = answers.apiGateway && answers.sharedApi;
+    const httpApi = answers.apiGateway && !shared ? samHttpApiResource() : "";
+    const sharedLayer = answers.layer ? samSharedLayerResource(answers, "service") : "";
+    const functions = service.functions
+        .map((fn) => samFunction(answers, service, fn, envKeys, "service"))
+        .join("\n");
+    const routes = shared
+        ? service.functions.map((fn) => samRawRoute(fn)).join("")
+        : "";
+    const dynamo = answers.database === "dynamodb" ? samDynamoResources(service) : "";
+    // Only a service that owns its API has a URL of its own to report upward.
+    const outputs = answers.apiGateway && !shared
+        ? `
+Outputs:
+  HttpApiUrl:
+    Description: HTTP API URL for the ${service.name} service
+    Value: !Sub https://\${HttpApi}.execute-api.\${AWS::Region}.amazonaws.com
+`
+        : "";
+    const parameters = shared
+        ? samParameters(envKeys, [sharedApiParameter()])
+        : samParameters(envKeys);
+    return `AWSTemplateFormatVersion: "2010-09-09"
+Transform: AWS::Serverless-2016-10-31
+Description: ${service.name} service
+
+${parameters}Globals:
+  Function:
+    Timeout: 10
+    MemorySize: ${answers.memorySize}
+
+Resources:
+${httpApi}${sharedLayer}${functions}${routes}${dynamo}${outputs}`;
+}
+// Everything in one file: a single HTTP API, one layer, every function beside them.
+// This is what "slskit run" serves, never what gets deployed. SAM local cannot resolve
+// an API that lives in a parent stack, so a shared-API project is flattened for local
+// use -- generated from the same manifest as the real templates, so it cannot drift.
+function samFlatTemplate(answers, apps, envKeys = []) {
+    const httpApi = answers.apiGateway ? samHttpApiResource() : "";
+    const sharedLayer = answers.layer ? samSharedLayerResource(answers, "root") : "";
+    const functions = apps
+        .flatMap((service) => service.functions.map((fn) => samFunction(answers, service, fn, envKeys, "root")))
+        .join("\n");
+    const dynamo = answers.database === "dynamodb"
+        ? apps.map((service) => samDynamoResources(service)).join("")
+        : "";
+    const outputs = answers.apiGateway
+        ? `
+Outputs:
+  ApiUrl:
+    Description: HTTP API URL for every function in this project
+    Value: !Sub https://\${HttpApi}.execute-api.\${AWS::Region}.amazonaws.com
+`
+        : "";
+    return `AWSTemplateFormatVersion: "2010-09-09"
+Transform: AWS::Serverless-2016-10-31
+Description: ${answers.name}
+
+${samParameters(envKeys)}Globals:
+  Function:
+    Timeout: 10
+    MemorySize: ${answers.memorySize}
+
+Resources:
+${httpApi}${sharedLayer}${functions}${dynamo}${outputs}`;
+}
+function samRootTemplate(answers, apps, envKeys = []) {
+    const shared = answers.apiGateway && answers.sharedApi;
+    const parameterNames = [environments_js_1.APP_ENVIRONMENT_PARAM, ...stageParameterNames(envKeys)];
+    const passed = parameterNames.map((name) => `        ${name}: !Ref ${name}`);
+    // The API is created here, so its id is handed to every service that attaches to it.
+    if (shared) {
+        passed.push(`        ${SHARED_API_PARAM}: !Ref SharedHttpApi`);
+    }
+    const parametersBlock = passed.length > 0 ? `      Parameters:\n${passed.join("\n")}\n` : "";
+    const sharedApi = shared ? samSharedApiResources(answers) : "";
+    const services = apps
+        .map((service) => {
+        const resource = `${(0, helpers_js_1.pascal)(service.name)}Stack`;
+        return `  ${resource}:
+    Type: AWS::Serverless::Application
+    Properties:
+      Location: ${(0, types_js_1.serviceTemplatePath)(service.name)}
+${parametersBlock}`;
+    })
+        .join("\n");
+    // One shared API has one URL; per-service APIs each report their own.
+    const outputs = !answers.apiGateway
+        ? ""
+        : shared
+            ? `
+Outputs:
+  ApiUrl:
+    Description: HTTP API URL for every service in this project
+    Value: !Sub https://\${SharedHttpApi}.execute-api.\${AWS::Region}.amazonaws.com
+`
+            : `
+Outputs:
+${apps
+                .map((service) => `  ${(0, helpers_js_1.pascal)(service.name)}ApiUrl:
+    Description: HTTP API URL for the ${service.name} service
+    Value: !GetAtt ${(0, helpers_js_1.pascal)(service.name)}Stack.Outputs.HttpApiUrl`)
+                .join("\n")}
+`;
+    return `AWSTemplateFormatVersion: "2010-09-09"
+Transform: AWS::Serverless-2016-10-31
+Description: ${answers.name} root stack
+
+${samParameters(envKeys)}Resources:
+${sharedApi}${services}${outputs}`;
+}

package/dist/commands/init/templates/shared-code.d.ts

@@ -0,0 +1,6 @@
+import type { InitAnswers } from "../types.js";
+export declare function sharedLogger(runtime: InitAnswers["runtime"]): string;
+export declare function sharedLayerLogger(): string;
+export declare function sharedLayerLoggerTypes(): string;
+export declare function sharedDb(answers: InitAnswers): string | undefined;
+export declare function prismaSchema(): string;

package/dist/commands/init/templates/shared-code.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedLogger = sharedLogger;
+exports.sharedLayerLogger = sharedLayerLogger;
+exports.sharedLayerLoggerTypes = sharedLayerLoggerTypes;
+exports.sharedDb = sharedDb;
+exports.prismaSchema = prismaSchema;
+function sharedLogger(runtime) {
+    if (runtime === "python") {
+        return `import logging
+
+logger = logging.getLogger("slskit")
+if not logger.handlers:
+    logging.basicConfig(level=logging.INFO)
+`;
+    }
+    if (runtime === "typescript") {
+        return `export const logger = {
+  info(message: string, extra?: unknown): void {
+    console.log(JSON.stringify({ level: "info", message, extra }));
+  },
+  error(message: string, extra?: unknown): void {
+    console.error(JSON.stringify({ level: "error", message, extra }));
+  },
+};
+`;
+    }
+    return `export const logger = {
+  info(message, extra) {
+    console.log(JSON.stringify({ level: "info", message, extra }));
+  },
+  error(message, extra) {
+    console.error(JSON.stringify({ level: "error", message, extra }));
+  },
+};
+`;
+}
+function sharedLayerLogger() {
+    return `exports.logger = {
+  info(message, extra) {
+    console.log(JSON.stringify({ level: "info", message, extra }));
+  },
+  error(message, extra) {
+    console.error(JSON.stringify({ level: "error", message, extra }));
+  },
+};
+`;
+}
+// The layer ships runtime JS, so a TypeScript project needs these declarations to type it.
+function sharedLayerLoggerTypes() {
+    return `export declare const logger: {
+  info(message: string, extra?: unknown): void;
+  error(message: string, extra?: unknown): void;
+};
+`;
+}
+function sharedDb(answers) {
+    if (answers.database === "none") {
+        return undefined;
+    }
+    if (answers.runtime === "python") {
+        if (answers.database === "prisma") {
+            return `from prisma import Prisma
+
+prisma = Prisma()
+
+
+async def connect_db():
+    if not prisma.is_connected():
+        await prisma.connect()
+    return prisma
+`;
+        }
+        if (answers.database === "mongoose") {
+            return `import os
+from pymongo import MongoClient
+
+_client = None
+
+
+def connect_db():
+    global _client
+    if _client is None:
+        uri = os.environ.get("MONGODB_URI", "mongodb://127.0.0.1:27017/app")
+        _client = MongoClient(uri)
+    return _client.get_default_database()
+`;
+        }
+        return `import os
+import boto3
+
+dynamodb = boto3.resource("dynamodb")
+
+
+def users_table():
+    return dynamodb.Table(os.environ.get("USERS_TABLE", "users"))
+
+
+def products_table():
+    return dynamodb.Table(os.environ.get("PRODUCTS_TABLE", "products"))
+`;
+    }
+    if (answers.database === "prisma") {
+        return `import { PrismaClient } from "@prisma/client";
+
+export const prisma = new PrismaClient();
+`;
+    }
+    if (answers.database === "mongoose") {
+        const typed = answers.runtime === "typescript";
+        return `import mongoose from "mongoose";
+
+export async function connectDb()${typed ? ": Promise<typeof mongoose>" : ""} {
+  if (mongoose.connection.readyState === 0) {
+    const uri = process.env.MONGODB_URI ?? "mongodb://127.0.0.1:27017/app";
+    await mongoose.connect(uri);
+  }
+
+  return mongoose;
+}
+`;
+    }
+    return `import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+
+const client = new DynamoDBClient({});
+export const docClient = DynamoDBDocumentClient.from(client);
+
+export const USERS_TABLE = process.env.USERS_TABLE ?? "users";
+export const PRODUCTS_TABLE = process.env.PRODUCTS_TABLE ?? "products";
+`;
+}
+function prismaSchema() {
+    // rhel-openssl-3.0.x is the query engine for the Amazon Linux 2023 Lambda runtimes.
+    return `generator client {
+  provider      = "prisma-client-js"
+  binaryTargets = ["native", "rhel-openssl-3.0.x"]
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  password  String
+  createdAt DateTime @default(now())
+}
+
+model Product {
+  id        String   @id @default(cuid())
+  name      String
+  price     Int
+  createdAt DateTime @default(now())
+}
+`;
+}

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

@@ -0,0 +1,47 @@
+export type RuntimeId = "typescript" | "javascript" | "python";
+export type DatabaseId = "none" | "prisma" | "mongoose" | "dynamodb";
+export type MemorySize = 128 | 256 | 512 | 1024 | 2048 | 3008 | 4096 | 10240;
+export declare const MEMORY_SIZES: MemorySize[];
+export interface InitOptions {
+    name?: string;
+    runtime?: string;
+    database?: string;
+    apiGateway?: string | boolean;
+    sharedApi?: string | boolean;
+    layer?: string | boolean;
+    memory?: string | number;
+    force?: boolean;
+}
+export interface InitAnswers {
+    name: string;
+    runtime: RuntimeId;
+    database: DatabaseId;
+    apiGateway: boolean;
+    sharedApi: boolean;
+    layer: boolean;
+    memorySize: MemorySize;
+    force: boolean;
+}
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export interface ServiceFunction {
+    name: string;
+    httpPath: string;
+    method: HttpMethod;
+    runtime?: RuntimeId;
+    memorySize?: MemorySize;
+}
+export interface ServiceDef {
+    name: string;
+    functions: ServiceFunction[];
+}
+export declare const LAMBDA_APPS: ServiceDef[];
+export declare const INFRA_FILE = "template.yaml";
+export declare const TEMPLATES_DIR = "templates";
+export declare function lambdaRuntime(runtime: RuntimeId): string;
+export declare function handlerFileName(runtime: RuntimeId): string;
+export declare function sourceExt(runtime: RuntimeId): "ts" | "js" | "py";
+export declare const SRC_DIR = "src";
+export declare function sharedCodeDir(answers: InitAnswers): string;
+export declare function serviceTemplatePath(appName: string): string;
+export declare function runtimeFamily(runtime: RuntimeId): "node" | "python";
+export declare function sameRuntimeFamily(a: RuntimeId, b: RuntimeId): boolean;

package/dist/commands/init/types.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SRC_DIR = exports.TEMPLATES_DIR = exports.INFRA_FILE = exports.LAMBDA_APPS = exports.MEMORY_SIZES = void 0;
+exports.lambdaRuntime = lambdaRuntime;
+exports.handlerFileName = handlerFileName;
+exports.sourceExt = sourceExt;
+exports.sharedCodeDir = sharedCodeDir;
+exports.serviceTemplatePath = serviceTemplatePath;
+exports.runtimeFamily = runtimeFamily;
+exports.sameRuntimeFamily = sameRuntimeFamily;
+exports.MEMORY_SIZES = [
+    128, 256, 512, 1024, 2048, 3008, 4096, 10240,
+];
+exports.LAMBDA_APPS = [
+    {
+        name: "auth",
+        functions: [
+            { name: "login", httpPath: "/auth/login", method: "POST" },
+            { name: "register", httpPath: "/auth/register", method: "POST" },
+        ],
+    },
+    {
+        name: "product",
+        functions: [
+            { name: "getProducts", httpPath: "/products", method: "GET" },
+            { name: "createProduct", httpPath: "/products", method: "POST" },
+        ],
+    },
+];
+// Every generated project is an AWS SAM project: a root stack that nests one
+// template per application.
+exports.INFRA_FILE = "template.yaml";
+// Service templates are gathered in one directory rather than buried next to the
+// handlers, so the whole infrastructure of a project is readable in one place --
+// the thing that matters most once a project has more than a handful of services.
+exports.TEMPLATES_DIR = "templates";
+function lambdaRuntime(runtime) {
+    return runtime === "python" ? "python3.12" : "nodejs20.x";
+}
+function handlerFileName(runtime) {
+    if (runtime === "typescript") {
+        return "handler.ts";
+    }
+    if (runtime === "javascript") {
+        return "handler.js";
+    }
+    return "handler.py";
+}
+function sourceExt(runtime) {
+    if (runtime === "python") {
+        return "py";
+    }
+    return runtime === "typescript" ? "ts" : "js";
+}
+// Every generated source file lives under src/, which is also the Lambda CodeUri.
+exports.SRC_DIR = "src";
+function sharedCodeDir(answers) {
+    if (!answers.layer) {
+        return `${exports.SRC_DIR}/shared`;
+    }
+    return answers.runtime === "python"
+        ? `${exports.SRC_DIR}/shared/python`
+        : `${exports.SRC_DIR}/shared/nodejs`;
+}
+function serviceTemplatePath(appName) {
+    return `${exports.TEMPLATES_DIR}/${appName}.yaml`;
+}
+// Node and Python are different runtime families: a layer/db built for one can never
+// be attached to or imported by a function running the other.
+function runtimeFamily(runtime) {
+    return runtime === "python" ? "python" : "node";
+}
+function sameRuntimeFamily(a, b) {
+    return runtimeFamily(a) === runtimeFamily(b);
+}

package/dist/commands/rm/action.d.ts

@@ -0,0 +1,2 @@
+import type { RmOptions } from "./types.js";
+export declare function rmAction(options: RmOptions): Promise<void>;