@saws/core 2.0.0-beta.0 → 2.0.0-beta.11

package/dist/utils/dependency-management.js

@@ -0,0 +1,132 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileExists } from "./file-exists.js";
+export async function installDependencies(dependencies, options = {}) {
+    if (dependencies.length === 0)
+        return;
+    const rootDirectory = path.resolve(options.cwd ?? process.cwd());
+    const packageManager = await detectPackageManager(rootDirectory);
+    const args = installArguments(packageManager, dependencies, options.development ?? false, options.workspace);
+    await new Promise((resolve, reject) => {
+        const captureOutput = options.logSink != null;
+        const serviceName = options.serviceName ?? "system";
+        const child = spawn(packageManager, args, {
+            // Workspace-aware package managers must be run from the workspace root.
+            // Running npm from within a workspace can install into the root package
+            // instead of updating the generated service's package.json.
+            cwd: rootDirectory,
+            env: process.env,
+            stdio: captureOutput ? ["ignore", "pipe", "pipe"] : "inherit",
+        });
+        child.stdout?.on("data", (chunk) => {
+            options.logSink?.({
+                serviceName,
+                stream: "stdout",
+                chunk: chunk.toString("utf8"),
+                timestamp: new Date(),
+            });
+        });
+        child.stderr?.on("data", (chunk) => {
+            options.logSink?.({
+                serviceName,
+                stream: "stderr",
+                chunk: chunk.toString("utf8"),
+                timestamp: new Date(),
+            });
+        });
+        child.once("error", (error) => {
+            reject(new Error(`Unable to run ${packageManager}: ${error.message}`, { cause: error }));
+        });
+        child.once("close", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const reason = signal == null ? `exit code ${code ?? "unknown"}` : `signal ${signal}`;
+            reject(new Error(`${packageManager} failed to install dependencies with ${reason}`));
+        });
+    });
+}
+export async function hasDependency(dependency, cwd = process.cwd()) {
+    try {
+        const contents = await readFile(path.resolve(cwd, "package.json"), "utf8");
+        const packageJson = JSON.parse(contents);
+        return (packageJson.dependencies?.[dependency] != null ||
+            packageJson.devDependencies?.[dependency] != null);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function detectPackageManager(cwd) {
+    for (let directory = cwd;; directory = path.dirname(directory)) {
+        const packageManager = await readPackageManagerField(directory);
+        if (packageManager != null)
+            return packageManager;
+        for (const [lockfile, manager] of LOCKFILES) {
+            if (await fileExists(path.join(directory, lockfile)))
+                return manager;
+        }
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return "npm";
+    }
+}
+async function readPackageManagerField(directory) {
+    try {
+        const contents = await readFile(path.join(directory, "package.json"), "utf8");
+        const packageJson = JSON.parse(contents);
+        if (typeof packageJson.packageManager !== "string")
+            return undefined;
+        const name = packageJson.packageManager.split("@", 1)[0];
+        return isPackageManager(name) ? name : undefined;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function installArguments(packageManager, dependencies, development, workspace) {
+    switch (packageManager) {
+        case "npm":
+            return [
+                "install",
+                ...(workspace == null ? [] : ["--workspace", workspace]),
+                development ? "--save-dev" : "--save-prod",
+                ...dependencies,
+            ];
+        case "pnpm":
+            return [
+                ...(workspace == null ? [] : ["--filter", workspace]),
+                "add",
+                ...(development ? ["--dev"] : []),
+                ...dependencies,
+            ];
+        case "yarn":
+            return workspace == null
+                ? ["add", ...(development ? ["--dev"] : []), ...dependencies]
+                : ["workspace", workspace, "add", ...(development ? ["--dev"] : []), ...dependencies];
+        case "bun":
+            return [
+                "add",
+                ...(workspace == null ? [] : ["--filter", workspace]),
+                ...(development ? ["--dev"] : []),
+                ...dependencies,
+            ];
+    }
+}
+function isPackageManager(value) {
+    return value === "npm" || value === "pnpm" || value === "yarn" || value === "bun";
+}
+const LOCKFILES = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"],
+];

package/dist/utils/file-exists.d.ts

@@ -0,0 +1 @@
+export declare function fileExists(filePath: string): Promise<boolean>;

package/dist/utils/file-exists.js

@@ -0,0 +1,12 @@
+import { access } from "node:fs/promises";
+export async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}

package/dist/utils/generate-token.d.ts

@@ -0,0 +1 @@
+export declare const generateToken: () => Promise<string>;

package/dist/utils/generate-token.js

@@ -0,0 +1,13 @@
+import * as crypto from "crypto";
+export const generateToken = async () => {
+    return new Promise((resolve, reject) => {
+        crypto.randomBytes(20, (err, buffer) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(buffer.toString("hex"));
+            return;
+        });
+    });
+};

package/dist/utils/get-project-name.d.ts

@@ -0,0 +1 @@
+export declare const getProjectName: () => string;

package/dist/utils/get-project-name.js

@@ -0,0 +1,5 @@
+import { default as finder } from "find-package-json";
+export const getProjectName = () => {
+    const pkg = finder(import.meta.dirname).next().value;
+    return pkg.name;
+};

package/dist/utils/get-service-path.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/list-files.d.ts

@@ -0,0 +1 @@
+export declare function listFiles(directory: string): Promise<string[]>;

package/dist/utils/list-files.js

@@ -0,0 +1,17 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+export async function listFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/utils/on-exit.d.ts

@@ -0,0 +1 @@
+export declare const onProcessExit: (callback: () => void) => void;

package/dist/utils/on-exit.js

@@ -0,0 +1,14 @@
+let registeredFunctions = [];
+export const onProcessExit = (callback) => {
+    registeredFunctions.push(callback);
+};
+process.on("exit", () => {
+    registeredFunctions.forEach((f) => f());
+    registeredFunctions = [];
+    process.exit();
+});
+process.on("SIGINT", () => {
+    registeredFunctions.forEach((f) => f());
+    registeredFunctions = [];
+    process.exit();
+});

package/dist/utils/parameterized-env-var-name.d.ts

@@ -0,0 +1 @@
+export declare const parameterizedEnvVarName: (name: string, variable: string) => string;

package/dist/utils/parameterized-env-var-name.js

@@ -0,0 +1 @@
+export const parameterizedEnvVarName = (name, variable) => `${name.replace(/[^a-zA-Z\d]/g, "_").toUpperCase()}_${variable}`;

package/dist/utils/recursively-read-dir.d.ts

@@ -0,0 +1 @@
+export declare const recursivelyReadDir: (dir: string) => Promise<string[]>;

package/dist/utils/recursively-read-dir.js

@@ -0,0 +1,15 @@
+import { promises as fs } from "fs";
+import { resolve } from "path";
+export const recursivelyReadDir = async (dir) => {
+    const files = [];
+    const dirContents = await fs.readdir(dir, { withFileTypes: true });
+    for (const item of dirContents) {
+        if (item.isDirectory()) {
+            const nestedFiles = await recursivelyReadDir(resolve(dir, item.name));
+            files.push(...nestedFiles);
+            continue;
+        }
+        files.push(resolve(dir, item.name));
+    }
+    return files;
+};

package/dist/utils/retry-until.d.ts

@@ -0,0 +1 @@
+export declare const retryUntil: (callback: () => Promise<boolean>, timeout: number) => Promise<void>;

package/dist/utils/retry-until.js

@@ -0,0 +1,9 @@
+export const retryUntil = async (callback, timeout) => {
+    while (true) {
+        const done = await callback();
+        if (done)
+            break;
+        await new Promise((r) => setTimeout(r, timeout));
+    }
+    return;
+};

package/dist/utils/run-local.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeLogSink } from "../ServiceDefinition.js";
+export declare function runLocal(command: string, options?: {
+    dryRun?: boolean;
+    input?: string;
+    cwd?: string;
+    logSink?: RuntimeLogSink;
+    serviceName?: string;
+    signal?: AbortSignal;
+}): Promise<void>;

package/dist/utils/run-local.js

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process";
+export async function runLocal(command, options = {}) {
+    if (options.dryRun) {
+        if (options.logSink == null) {
+            console.log(`[dry-run:local] ${command}`);
+        }
+        else {
+            options.logSink({
+                serviceName: options.serviceName ?? "system",
+                stream: "stdout",
+                chunk: `[dry-run:local] ${command}\n`,
+                timestamp: new Date(),
+            });
+        }
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        if (options.signal?.aborted) {
+            reject(new Error(`local command aborted: ${command}`));
+            return;
+        }
+        const captureOutput = options.logSink != null;
+        const serviceName = options.serviceName ?? "system";
+        const child = spawn(command, {
+            cwd: options.cwd,
+            shell: true,
+            detached: true,
+            stdio: [
+                options.input == null ? "ignore" : "pipe",
+                captureOutput ? "pipe" : "inherit",
+                captureOutput ? "pipe" : "inherit",
+            ],
+        });
+        let aborted = false;
+        const abort = () => {
+            aborted = true;
+            if (child.pid == null)
+                return;
+            try {
+                process.kill(-child.pid, "SIGTERM");
+            }
+            catch (error) {
+                if (error.code !== "ESRCH") {
+                    options.logSink?.({
+                        serviceName: options.serviceName ?? "system",
+                        stream: "stderr",
+                        chunk: `Failed to stop local command: ${error.message}\n`,
+                        timestamp: new Date(),
+                    });
+                }
+            }
+        };
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.input != null) {
+            child.stdin?.end(options.input);
+        }
+        child.stdout?.on("data", (chunk) => {
+            options.logSink?.({
+                serviceName,
+                stream: "stdout",
+                chunk: chunk.toString("utf8"),
+                timestamp: new Date(),
+            });
+        });
+        child.stderr?.on("data", (chunk) => {
+            options.logSink?.({
+                serviceName,
+                stream: "stderr",
+                chunk: chunk.toString("utf8"),
+                timestamp: new Date(),
+            });
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            options.signal?.removeEventListener("abort", abort);
+            if (aborted) {
+                reject(new Error(`local command aborted: ${command}`));
+                return;
+            }
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`local command exited with code ${code}: ${command}`));
+        });
+    });
+}

package/dist/utils/shell-quote.d.ts

@@ -0,0 +1 @@
+export declare function shellQuote(value: string): string;

package/dist/utils/shell-quote.js

@@ -0,0 +1,3 @@
+export function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/utils/stage-outputs.d.ts

@@ -0,0 +1,3 @@
+export type Outputs = Record<string, string | number | boolean | null | undefined>;
+export declare const getStageOutputs: (stage: string) => Promise<Record<string, Outputs>>;
+export declare const writeStageOutputs: (newOutputs: Record<string, Outputs>, stage: string) => Promise<Record<string, Outputs>>;

package/dist/utils/stage-outputs.js

@@ -0,0 +1,24 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { SAWS_DIR } from "./constants.js";
+export const getStageOutputs = async (stage) => {
+    const outputPath = path.resolve(SAWS_DIR, `saws-${stage}-output.json`);
+    try {
+        await fs.stat(outputPath);
+        const outputsText = await fs.readFile(outputPath, { encoding: "utf-8" });
+        return JSON.parse(outputsText);
+    }
+    catch (err) {
+        return {};
+    }
+};
+export const writeStageOutputs = async (newOutputs, stage) => {
+    const currentOutputs = await getStageOutputs(stage);
+    // write outputs
+    const outputs = {
+        ...currentOutputs,
+        ...newOutputs,
+    };
+    await fs.writeFile(path.resolve(SAWS_DIR, `saws-${stage}-output.json`), JSON.stringify(outputs, null, 2));
+    return outputs;
+};

package/dist/utils/uppercase.d.ts

@@ -0,0 +1 @@
+export declare const uppercase: (text: string) => string;

package/dist/utils/uppercase.js

@@ -0,0 +1,4 @@
+export const uppercase = (text) => {
+    const [first, ...rest] = text;
+    return first.toUpperCase() + rest.join("");
+};

package/package.json

@@ -1,34 +1,47 @@
 {
   "name": "@saws/core",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.11",
+  "description": "",
+  "keywords": [],
+  "license": "MIT",
+  "author": "",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/shichongrui/saws.git",
-    "directory": "packages/core"
-  },
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+    "url": "git+https://github.com/shichongrui/saws.git"
   },
   "files": [
-    "dist"
+    "./dist"
   ],
-  "scripts": {
-    "prebuild": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test dist/*.test.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./ServiceDefinition": "./dist/ServiceDefinition.js",
+    "./get-saws-config": "./dist/get-saws-config.js",
+    "./Host": "./dist/Host.js",
+    "./global-hosts": "./dist/global-hosts.js",
+    "./host-readiness": "./dist/host-readiness.js",
+    "./secrets-manager": "./dist/secrets-manager.js",
+    "./utils/constants": "./dist/utils/constants.js",
+    "./utils/create-directories": "./dist/utils/create-directories.js",
+    "./utils/file-exists": "./dist/utils/file-exists.js",
+    "./utils/generate-token": "./dist/utils/generate-token.js",
+    "./utils/get-project-name": "./dist/utils/get-project-name.js",
+    "./utils/list-files": "./dist/utils/list-files.js",
+    "./utils/on-exit": "./dist/utils/on-exit.js",
+    "./utils/parameterized-env-var-name": "./dist/utils/parameterized-env-var-name.js",
+    "./utils/recursively-read-dir": "./dist/utils/recursively-read-dir.js",
+    "./utils/retry-until": "./dist/utils/retry-until.js",
+    "./utils/shell-quote": "./dist/utils/shell-quote.js",
+    "./utils/stage-outputs": "./dist/utils/stage-outputs.js",
+    "./utils/uppercase": "./dist/utils/uppercase.js",
+    "./utils/create-file-if-not-exists": "./dist/utils/create-file-if-not-exists.js",
+    "./utils/dependency-management": "./dist/utils/dependency-management.js",
+    "./utils/run-local": "./dist/utils/run-local.js"
   },
   "dependencies": {
-    "commander": "^14.0.3",
-    "typescript": "^5.3.3"
+    "find-package-json": "^1.2.0"
   },
   "devDependencies": {
-    "@types/node": "^20.11.19"
+    "@types/find-package-json": "^1.2.7"
   }
 }

package/dist/context.d.ts

@@ -1,41 +0,0 @@
-import type { ServiceDefinition } from "./service-definition.js";
-export type StageName = "local" | string;
-export interface RuntimeContextConfig {
-    stage: StageName;
-    rootDir?: string;
-    env?: Record<string, string>;
-    dryRun?: boolean;
-    logSink?: RuntimeLogSink;
-    currentServiceName?: string;
-}
-export interface RuntimeLogEntry {
-    serviceName: string;
-    stream: "stdout" | "stderr";
-    chunk: string;
-    timestamp: Date;
-}
-export type RuntimeLogSink = (entry: RuntimeLogEntry) => void;
-export declare class RuntimeContext {
-    readonly stage: StageName;
-    readonly rootDir: string;
-    readonly env: Record<string, string>;
-    readonly dryRun: boolean;
-    readonly logSink?: RuntimeLogSink;
-    readonly currentServiceName?: string;
-    constructor(config: RuntimeContextConfig);
-    writeLog(chunk: string, stream?: "stdout" | "stderr"): void;
-}
-export declare class InitContext extends RuntimeContext {
-}
-export declare class DevContext extends RuntimeContext {
-}
-export declare class DeployContext extends RuntimeContext {
-}
-export declare class ExitContext extends RuntimeContext {
-}
-export declare function assertValidStageName(stage: string): void;
-export interface DependencyEnvironment {
-    service: ServiceDefinition;
-    variables: Record<string, string>;
-}
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAEzC,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAE9D,qBAAa,cAAc;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;gBAEzB,MAAM,EAAE,oBAAoB;IAUxC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,QAAQ,GAAG,QAAmB;CAQ/D;AAED,qBAAa,WAAY,SAAQ,cAAc;CAAG;AAClD,qBAAa,UAAW,SAAQ,cAAc;CAAG;AACjD,qBAAa,aAAc,SAAQ,cAAc;CAAG;AACpD,qBAAa,WAAY,SAAQ,cAAc;CAAG;AAElD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,QAMjD;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC"}

package/dist/context.js

@@ -1,38 +0,0 @@
-export class RuntimeContext {
-    stage;
-    rootDir;
-    env;
-    dryRun;
-    logSink;
-    currentServiceName;
-    constructor(config) {
-        assertValidStageName(config.stage);
-        this.stage = config.stage;
-        this.rootDir = config.rootDir ?? process.cwd();
-        this.env = config.env ?? process.env;
-        this.dryRun = config.dryRun ?? false;
-        this.logSink = config.logSink;
-        this.currentServiceName = config.currentServiceName;
-    }
-    writeLog(chunk, stream = "stdout") {
-        this.logSink?.({
-            serviceName: this.currentServiceName ?? "system",
-            stream,
-            chunk,
-            timestamp: new Date(),
-        });
-    }
-}
-export class InitContext extends RuntimeContext {
-}
-export class DevContext extends RuntimeContext {
-}
-export class DeployContext extends RuntimeContext {
-}
-export class ExitContext extends RuntimeContext {
-}
-export function assertValidStageName(stage) {
-    if (!/^[a-z0-9][a-z0-9._-]*$/.test(stage)) {
-        throw new Error(`Invalid stage "${stage}": stages must start with a lower-case letter or number and contain only lower-case letters, numbers, ".", "_", or "-"`);
-    }
-}

package/dist/context.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=context.test.d.ts.map

package/dist/context.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.test.d.ts","sourceRoot":"","sources":["../src/context.test.ts"],"names":[],"mappings":""}

package/dist/context.test.js

@@ -1,13 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { RuntimeContext } from "./context.js";
-test("accepts stage names that are safe for Docker resources and paths", () => {
-    for (const stage of ["local", "production", "review-42", "release_1.2"]) {
-        assert.equal(new RuntimeContext({ stage }).stage, stage);
-    }
-});
-test("rejects unsafe or ambiguous stage names", () => {
-    for (const stage of ["", "../production", "Production", "review 42", "."]) {
-        assert.throws(() => new RuntimeContext({ stage }), /Invalid stage/);
-    }
-});

package/dist/find-service-definition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-service-definition.d.ts","sourceRoot":"","sources":["../src/find-service-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,MAAM,GACX,iBAAiB,CA+BnB"}

package/dist/find-service-definition.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=find-service-definition.test.d.ts.map

package/dist/find-service-definition.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-service-definition.test.d.ts","sourceRoot":"","sources":["../src/find-service-definition.test.ts"],"names":[],"mappings":""}

package/dist/find-service-definition.test.js

@@ -1,44 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { findServiceDefinition } from "./find-service-definition.js";
-import { ServiceDefinition } from "./service-definition.js";
-test("finds a nested service by its configured name", () => {
-    const database = new ServiceDefinition({ name: "db" });
-    const api = new ServiceDefinition({
-        name: "api",
-        dependencies: [database],
-    });
-    const root = new ServiceDefinition({
-        name: "app",
-        dependencies: [api],
-    });
-    assert.equal(findServiceDefinition(root, "db"), database);
-});
-test("allows one shared service instance to appear in multiple branches", () => {
-    const database = new ServiceDefinition({ name: "db" });
-    const root = new ServiceDefinition({
-        name: "app",
-        dependencies: [
-            new ServiceDefinition({ name: "api", dependencies: [database] }),
-            new ServiceDefinition({ name: "worker", dependencies: [database] }),
-        ],
-    });
-    assert.equal(findServiceDefinition(root, "db"), database);
-});
-test("reports available services when the requested service is missing", () => {
-    const root = new ServiceDefinition({
-        name: "app",
-        dependencies: [new ServiceDefinition({ name: "db" })],
-    });
-    assert.throws(() => findServiceDefinition(root, "missing"), /Available services: app, db/);
-});
-test("rejects duplicate names assigned to different service instances", () => {
-    const root = new ServiceDefinition({
-        name: "app",
-        dependencies: [
-            new ServiceDefinition({ name: "worker" }),
-            new ServiceDefinition({ name: "worker" }),
-        ],
-    });
-    assert.throws(() => findServiceDefinition(root, "worker"), /Service name "worker" is ambiguous/);
-});

package/dist/get-saws-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-saws-config.d.ts","sourceRoot":"","sources":["../src/get-saws-config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,wBAAsB,aAAa,CACjC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAuB5B"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC"}