@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/scan/project.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectDependency = projectDependency;
+exports.projectDependencies = projectDependencies;
+exports.projectName = projectName;
+exports.projectFramework = projectFramework;
+exports.packageVersion = packageVersion;
+const frameworks_1 = require("@vercel/frameworks");
+const fs_detectors_1 = require("@vercel/fs-detectors");
+const fs_1 = require("fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+/**
+ * Returns true if the project is dependant on a package.
+ */
+function projectDependency(packageName, projectRoot) {
+    return projectDependencies(projectRoot).some((dep) => dep === packageName);
+}
+/**
+ * Returns all project dependencies
+ */
+function projectDependencies(projectRoot) {
+    const packageJson = parsePackageJson(projectRoot);
+    return Object.keys(packageJson.dependencies ?? {});
+}
+/**
+ * Returns the project name (from package.json)
+ */
+function projectName(projectRoot) {
+    const packageJson = parsePackageJson(projectRoot);
+    if (packageJson.name) {
+        return packageJson.name;
+    }
+}
+/**
+ * Returns the slug (unique identifier) of the framework
+ * used in the current project.
+ *
+ * Frameworks are defected wirth the package: `@vercel/fs-detectors`
+ */
+async function projectFramework(projectRoot) {
+    const result = await (0, fs_detectors_1.detectFrameworks)({
+        fs: new fs_detectors_1.LocalFileSystemDetector(projectRoot ?? (0, node_process_1.cwd)()),
+        frameworkList: frameworks_1.frameworkList,
+    });
+    return result[0]?.slug ?? undefined;
+}
+function parsePackageJson(projectRoot) {
+    return JSON.parse((0, fs_1.readFileSync)(node_path_1.default.join(projectRoot ?? (0, node_process_1.cwd)(), "package.json")).toString());
+}
+/**
+ * Returns the installed version of a package or `undefined` if the package is not installed.
+ */
+async function packageVersion(packageName, projectRoot) {
+    const list = await npmList(projectRoot);
+    return (list.dependencies ?? {})[packageName]?.version;
+}
+async function npmList(projectRoot) {
+    return new Promise((resolve, reject) => {
+        const lines = [];
+        const list = (0, node_child_process_1.spawn)("npm", ["list", "--json"], projectRoot
+            ? {
+                cwd: projectRoot,
+            }
+            : undefined);
+        list.stdout.on("data", (chunks) => lines.push(chunks.toString()));
+        list.stderr.on("data", (chunks) => reject(chunks.toString()));
+        list.on("close", (code) => {
+            if (code !== 0) {
+                throw new Error(`npm list command finished with code ${code}`);
+            }
+            resolve(JSON.parse(lines.join()));
+        });
+    });
+}

package/dist/cjs/scan/workload-imports.d.ts

@@ -0,0 +1,21 @@
+import { type Bucket, type Cron, type PostgresDatabase, type Redis, type Task } from "../workloads.js";
+import type { StatefulWorkloadWithClient } from "../workloads/stateful/stateful-workload.js";
+import type { AnyBroadcast } from "../workloads/stateless/broadcast/router.js";
+export declare function importWorkloads(): Promise<WorkloadImports>;
+export interface WorkloadImport<I> {
+    src: string;
+    workload: I;
+}
+export declare class WorkloadImports {
+    #private;
+    constructor();
+    get workloadsWithContainers(): (PostgresDatabase | Redis | Bucket | AnyBroadcast)[];
+    get Redis(): WorkloadImport<Redis>[];
+    get PostgresDatabase(): WorkloadImport<PostgresDatabase>[];
+    get Bucket(): WorkloadImport<Bucket>[];
+    get Cron(): WorkloadImport<Cron>[];
+    get Task(): WorkloadImport<Task<unknown>>[];
+    get Broadcast(): WorkloadImport<AnyBroadcast>[];
+    addBroadcast(src: string, workload: any): void;
+    add(src: string, workload: StatefulWorkloadWithClient): void;
+}

package/dist/cjs/scan/workload-imports.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _WorkloadImports_importsByWorkload, _WorkloadImports_imports;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkloadImports = void 0;
+exports.importWorkloads = importWorkloads;
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+const picocolors_1 = __importDefault(require("picocolors"));
+const configuration_js_1 = require("../configuration.js");
+const assertions_js_1 = require("../workloads/assertions.js");
+async function importWorkloads() {
+    const workloadsPath = node_path_1.default.join((0, node_process_1.cwd)(), (await (0, configuration_js_1.workloadsConfiguration)()).workloadsPath);
+    if (!(0, fs_1.existsSync)(workloadsPath)) {
+        console.log(`${picocolors_1.default.red("error")} Workloads folder not found`);
+        console.log("Check your configuration file: ./monolayer.config.ts");
+        (0, node_process_1.exit)(1);
+    }
+    const files = await promises_1.default.readdir(workloadsPath);
+    const imports = new WorkloadImports();
+    for (const fileName of files) {
+        if (fileName.endsWith(".ts") && !fileName.endsWith(".d.ts")) {
+            const importPath = node_path_1.default.join(workloadsPath, fileName);
+            const imported = (await Promise.resolve(`${importPath}`).then(s => __importStar(require(s))));
+            for (const [, workload] of Object.entries(imported)) {
+                if (workload !== undefined) {
+                    const workloadKind = workload.constructor.name;
+                    const workloadPath = node_path_1.default.relative((0, node_process_1.cwd)(), importPath);
+                    if (validWorkload(workloadKind)) {
+                        imports.add(workloadPath, workload);
+                    }
+                }
+            }
+        }
+    }
+    return imports;
+}
+const validConstructor = [
+    "PostgresDatabase",
+    "Redis",
+    "Bucket",
+    "Cron",
+    "Task",
+    "Broadcast",
+];
+function validWorkload(workloadConstructor) {
+    return validConstructor.includes(workloadConstructor);
+}
+class WorkloadImports {
+    constructor() {
+        _WorkloadImports_importsByWorkload.set(this, void 0);
+        _WorkloadImports_imports.set(this, []);
+        __classPrivateFieldSet(this, _WorkloadImports_importsByWorkload, {
+            PostgresDatabase: [],
+            Bucket: [],
+            Redis: [],
+            Cron: [],
+            Task: [],
+            Broadcast: [],
+        }, "f");
+    }
+    get workloadsWithContainers() {
+        return [
+            ...this.Bucket,
+            ...this.PostgresDatabase,
+            ...this.Redis,
+            ...this.Broadcast,
+        ].map((i) => i.workload);
+    }
+    get Redis() {
+        return __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").Redis;
+    }
+    get PostgresDatabase() {
+        return __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").PostgresDatabase;
+    }
+    get Bucket() {
+        return __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").Bucket;
+    }
+    get Cron() {
+        return __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").Cron;
+    }
+    get Task() {
+        return __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").Task;
+    }
+    get Broadcast() {
+        return __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").Broadcast;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    addBroadcast(src, workload) {
+        __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f").Broadcast = [{ src, workload }];
+    }
+    add(src, workload) {
+        if (validWorkload(workload.constructor.name)) {
+            const key = workload.constructor.name;
+            if (__classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key] === undefined) {
+                __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key] = [];
+            }
+            switch (key) {
+                case "Redis":
+                    (0, assertions_js_1.assertRedis)(workload);
+                    __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key].push({
+                        src,
+                        workload,
+                    });
+                    break;
+                case "Bucket":
+                    (0, assertions_js_1.assertBucket)(workload);
+                    __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key].push({
+                        src,
+                        workload,
+                    });
+                    break;
+                case "PostgresDatabase":
+                    (0, assertions_js_1.assertPostgresDatabase)(workload);
+                    __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key].push({
+                        src,
+                        workload,
+                    });
+                    break;
+                case "Cron":
+                    (0, assertions_js_1.assertCron)(workload);
+                    __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key].push({
+                        src,
+                        workload,
+                    });
+                    break;
+                case "Task":
+                    (0, assertions_js_1.assertTask)(workload);
+                    __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key].push({
+                        src,
+                        workload,
+                    });
+                    break;
+                case "Broadcast":
+                    (0, assertions_js_1.assertBroadcast)(workload);
+                    __classPrivateFieldGet(this, _WorkloadImports_importsByWorkload, "f")[key].push({
+                        src,
+                        workload,
+                    });
+                    break;
+            }
+        }
+        __classPrivateFieldGet(this, _WorkloadImports_imports, "f").push({
+            src,
+            workload,
+        });
+    }
+}
+exports.WorkloadImports = WorkloadImports;
+_WorkloadImports_importsByWorkload = new WeakMap(), _WorkloadImports_imports = new WeakMap();

package/dist/cjs/test-helpers/postgres.d.ts

@@ -0,0 +1,13 @@
+import type { PostgresDatabase } from "../workloads/stateful/postgres-database.js";
+/**
+ * Truncates all the tables in a {@link PostgresDatabase} workload.
+ */
+export declare function truncatePostgresTables(
+/**
+ * PostgresDatabase workload
+ */
+workload: PostgresDatabase, 
+/**
+ * Schema name (default: `public`)
+ */
+schemaName?: string): Promise<void>;

package/dist/cjs/test-helpers/postgres.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncatePostgresTables = truncatePostgresTables;
+/**
+ * Truncates all the tables in a {@link PostgresDatabase} workload.
+ */
+async function truncatePostgresTables(
+/**
+ * PostgresDatabase workload
+ */
+workload, 
+/**
+ * Schema name (default: `public`)
+ */
+schemaName) {
+    const pg = await Promise.resolve().then(() => __importStar(require("pg")));
+    const pool = new pg.Pool({
+        connectionString: process.env[workload.connectionStringEnvVar],
+    });
+    const result = await pool.query(`
+		SELECT c.relname as table_name, n.nspname as schema_name
+		FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+		WHERE n.nspname = '${schemaName ?? "public"}'
+		AND c.relkind IN ('r','p');`);
+    const tables = result.rows;
+    const queries = tables.map((table) => `TRUNCATE TABLE ${table.schema_name}.${table.table_name} RESTART IDENTITY CASCADE;`);
+    await pool.query(queries.join("\n"));
+    await pool.end();
+}

package/dist/cjs/test-helpers/redis.d.ts

@@ -0,0 +1,13 @@
+import type { Redis } from "../workloads/stateful/redis.js";
+/**
+ * Deletes all the keys of a {@link Redis} workload database.
+ */
+export declare function flushRedis(
+/**
+ * Redis workload
+ */
+workload: Redis, 
+/**
+ * Redis database (default: 0)
+ */
+db?: number): Promise<void>;

package/dist/cjs/test-helpers/redis.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushRedis = flushRedis;
+/**
+ * Deletes all the keys of a {@link Redis} workload database.
+ */
+async function flushRedis(
+/**
+ * Redis workload
+ */
+workload, 
+/**
+ * Redis database (default: 0)
+ */
+db) {
+    const Redis = (await Promise.resolve().then(() => __importStar(require("ioredis")))).Redis;
+    const client = new Redis(process.env[workload.connectionStringEnvVar]);
+    if (db) {
+        await client.select(db);
+    }
+    await client.flushdb();
+    client.disconnect();
+}

package/dist/cjs/test-helpers/task.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutionId } from "../workloads/stateless/task/perform-now.js";
+import type { Task } from "../workloads/stateless/task/task.js";
+export interface PerformedTask<P> {
+    executionId: ExecutionId;
+    data: P;
+}
+/**
+ * Returns all the performed tasks for a `Task` workload.
+ */
+export declare function performedTasks<P>(task: Task<P>): PerformedTask<P>[];
+/**
+ * Deletes all the performed tasks for a `Task` workload.
+ */
+export declare function clearPerformedTasks<P>(task: Task<P>): void;

package/dist/cjs/test-helpers/task.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performedTasks = performedTasks;
+exports.clearPerformedTasks = clearPerformedTasks;
+const local_js_1 = require("../workloads/stateless/task/local.js");
+/**
+ * Returns all the performed tasks for a `Task` workload.
+ */
+function performedTasks(task) {
+    return (0, local_js_1.dispatcherForTask)(task);
+}
+/**
+ * Deletes all the performed tasks for a `Task` workload.
+ */
+function clearPerformedTasks(task) {
+    const dispatchers = local_js_1.testDispatchers;
+    delete dispatchers[task.id];
+}

package/dist/cjs/test-helpers.d.ts

@@ -0,0 +1,3 @@
+export { truncatePostgresTables } from "./test-helpers/postgres.js";
+export { flushRedis } from "./test-helpers/redis.js";
+export { clearPerformedTasks, performedTasks, type PerformedTask, } from "./test-helpers/task.js";

package/dist/cjs/test-helpers.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performedTasks = exports.clearPerformedTasks = exports.flushRedis = exports.truncatePostgresTables = void 0;
+var postgres_js_1 = require("./test-helpers/postgres.js");
+Object.defineProperty(exports, "truncatePostgresTables", { enumerable: true, get: function () { return postgres_js_1.truncatePostgresTables; } });
+var redis_js_1 = require("./test-helpers/redis.js");
+Object.defineProperty(exports, "flushRedis", { enumerable: true, get: function () { return redis_js_1.flushRedis; } });
+var task_js_1 = require("./test-helpers/task.js");
+Object.defineProperty(exports, "clearPerformedTasks", { enumerable: true, get: function () { return task_js_1.clearPerformedTasks; } });
+Object.defineProperty(exports, "performedTasks", { enumerable: true, get: function () { return task_js_1.performedTasks; } });

package/dist/cjs/workloads/app-lifecycle/after-rollout.d.ts

@@ -0,0 +1,22 @@
+import { LifecycleWorkload, type LifecycleWorkloadOptions } from "../../workloads/app-lifecycle/lifecycle-workload.js";
+/**
+ * Workload for defining an npm script to run after rolling out a new application version.
+ *
+ * @example
+ * ```ts
+ * import { AfterRollout } from "@monolayer/sdk";
+ *
+ * const rollout = new AfterRollout("after-rollout-1",{
+ *   script: "notify",
+ * });
+ *
+ * export rollout;
+ * ```
+ */
+export declare class AfterRollout extends LifecycleWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id: string, options: LifecycleWorkloadOptions);
+}

package/dist/cjs/workloads/app-lifecycle/after-rollout.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfterRollout = void 0;
+const lifecycle_workload_js_1 = require("../../workloads/app-lifecycle/lifecycle-workload.js");
+/**
+ * Workload for defining an npm script to run after rolling out a new application version.
+ *
+ * @example
+ * ```ts
+ * import { AfterRollout } from "@monolayer/sdk";
+ *
+ * const rollout = new AfterRollout("after-rollout-1",{
+ *   script: "notify",
+ * });
+ *
+ * export rollout;
+ * ```
+ */
+class AfterRollout extends lifecycle_workload_js_1.LifecycleWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id, options) {
+        super(id, options);
+    }
+}
+exports.AfterRollout = AfterRollout;

package/dist/cjs/workloads/app-lifecycle/before-rollout.d.ts

@@ -0,0 +1,22 @@
+import { LifecycleWorkload, type LifecycleWorkloadOptions } from "../../workloads/app-lifecycle/lifecycle-workload.js";
+/**
+ * Workload for defining an npm script to run before rolling out a new application version.
+ *
+ * @example
+ * ```ts
+ * import { BeforeRollout } from "@monolayer/sdk";
+ *
+ * const rollout = new BeforeRollout("before-1", {
+ *   script: "db:migrate",
+ * });
+ *
+ * export default rollout;
+ * ```
+ */
+export declare class BeforeRollout extends LifecycleWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id: string, options: LifecycleWorkloadOptions);
+}

package/dist/cjs/workloads/app-lifecycle/before-rollout.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeforeRollout = void 0;
+const lifecycle_workload_js_1 = require("../../workloads/app-lifecycle/lifecycle-workload.js");
+/**
+ * Workload for defining an npm script to run before rolling out a new application version.
+ *
+ * @example
+ * ```ts
+ * import { BeforeRollout } from "@monolayer/sdk";
+ *
+ * const rollout = new BeforeRollout("before-1", {
+ *   script: "db:migrate",
+ * });
+ *
+ * export default rollout;
+ * ```
+ */
+class BeforeRollout extends lifecycle_workload_js_1.LifecycleWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id, options) {
+        super(id, options);
+    }
+}
+exports.BeforeRollout = BeforeRollout;

package/dist/cjs/workloads/app-lifecycle/bootstrap.d.ts

@@ -0,0 +1,22 @@
+import { LifecycleWorkload, type LifecycleWorkloadOptions } from "../../workloads/app-lifecycle/lifecycle-workload.js";
+/**
+ * Workload for defining bootstrap an npm script to run when rolling out a fresh application.
+ *
+ * @example
+ * ```ts
+ * import { Bootstrap } from "@monolayer/sdk";
+ *
+ * const bootstrap = new Bootstrap("bootstrap", {
+ *   script: "db:create",
+ * });
+ *
+ * export default bootstrap;
+ * ```
+ */
+export declare class Bootstrap extends LifecycleWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id: string, options: LifecycleWorkloadOptions);
+}

package/dist/cjs/workloads/app-lifecycle/bootstrap.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bootstrap = void 0;
+const lifecycle_workload_js_1 = require("../../workloads/app-lifecycle/lifecycle-workload.js");
+/**
+ * Workload for defining bootstrap an npm script to run when rolling out a fresh application.
+ *
+ * @example
+ * ```ts
+ * import { Bootstrap } from "@monolayer/sdk";
+ *
+ * const bootstrap = new Bootstrap("bootstrap", {
+ *   script: "db:create",
+ * });
+ *
+ * export default bootstrap;
+ * ```
+ */
+class Bootstrap extends lifecycle_workload_js_1.LifecycleWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id, options) {
+        super(id, options);
+    }
+}
+exports.Bootstrap = Bootstrap;

package/dist/cjs/workloads/app-lifecycle/lifecycle-workload.d.ts

@@ -0,0 +1,11 @@
+import { Workload } from "../../workloads/workload.js";
+export interface LifecycleWorkloadOptions {
+    /**
+     * Array of script names defined in `package.json`.
+     */
+    script: string;
+}
+export declare abstract class LifecycleWorkload extends Workload {
+    script: LifecycleWorkloadOptions["script"];
+    constructor(id: string, options: LifecycleWorkloadOptions);
+}

package/dist/cjs/workloads/app-lifecycle/lifecycle-workload.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleWorkload = void 0;
+const workload_js_1 = require("../../workloads/workload.js");
+class LifecycleWorkload extends workload_js_1.Workload {
+    constructor(id, options) {
+        super(id);
+        this.script = options.script;
+    }
+}
+exports.LifecycleWorkload = LifecycleWorkload;

package/dist/cjs/workloads/assertions.d.ts

@@ -0,0 +1,13 @@
+import type { Bucket } from "../workloads/stateful/bucket.js";
+import type { PostgresDatabase } from "../workloads/stateful/postgres-database.js";
+import type { Redis } from "../workloads/stateful/redis.js";
+import type { Cron } from "../workloads/stateless/cron.js";
+import type { Task } from "../workloads/stateless/task/task.js";
+import type { Workload } from "../workloads/workload.js";
+import type { AnyBroadcast } from "./stateless/broadcast/router.js";
+export declare function assertRedis(workload: Workload): asserts workload is Redis;
+export declare function assertPostgresDatabase(workload: Workload): asserts workload is PostgresDatabase;
+export declare function assertBucket(workload: Workload): asserts workload is Bucket;
+export declare function assertCron(workload: Workload): asserts workload is Cron;
+export declare function assertTask(workload: Workload): asserts workload is Task<unknown>;
+export declare function assertBroadcast(workload: Workload): asserts workload is AnyBroadcast;