@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/configuration.d.ts

@@ -0,0 +1,65 @@
+export interface Configuration {
+    /**
+     * Path to a folder with workloads.
+     *
+     */
+    workloadsPath: string;
+    /**
+     * Container configurations.
+     */
+    containers?: {
+        /**
+         * @default { imageName: "postgres:16.5-alpine3.20", exposedPorts: [ { container: 5432, host: 5432 } ] }
+         */
+        postgresDatabase?: ContainerConfig;
+        /**
+         * @default
+         * { imageName: "redis:7.4.1-alpine3.20", exposedPorts: [ { container: 6379, host: 6379 } ] }
+         */
+        redis?: ContainerConfig;
+        /**
+         * @default
+         * { imageName: "mysql:8.4.3", exposedPorts: [ { container: 3306, host: 3306 } ] }
+         */
+        mySqlDatabase?: ContainerConfig;
+        /**
+         * @default
+         * { imageName: "localstack/localstack:3.8.1", exposedPorts: [ { container: 4566, host: 4566 } ] }
+         */
+        minio?: ContainerConfig;
+    };
+    /**
+     * Names of the dotenv files to write the workloads' connection strings.
+     */
+    envFileName?: {
+        /**
+         * File name for development.
+         *
+         * @default
+         * .env.local
+         */
+        development?: string;
+        /**
+         * File name for test.
+         *
+         * @default
+         * .env.test.local
+         */
+        test?: string;
+    };
+}
+export interface ContainerConfig {
+    /**
+     * Docker image name.
+     */
+    imageName?: string;
+    /**
+     * Host port to publish the exposed container port.
+     */
+    exposedPorts?: {
+        container: number;
+        host: number;
+    }[];
+}
+export declare const workloadsConfiguration: () => Promise<Configuration>;
+export declare const packageName: any;

package/dist/cjs/configuration.js

@@ -0,0 +1,45 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageName = exports.workloadsConfiguration = void 0;
+const remember_1 = require("@epic-web/remember");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+async function importConfig() {
+    const imported = await Promise.resolve(`${node_path_1.default.join((0, node_process_1.cwd)(), "monolayer.config.ts")}`).then(s => __importStar(require(s)));
+    return imported.default && imported.default.default
+        ? imported.default.default
+        : imported.default;
+}
+const workloadsConfiguration = () => (0, remember_1.remember)("workloadsConfiguration", async () => await importConfig());
+exports.workloadsConfiguration = workloadsConfiguration;
+exports.packageName = (0, remember_1.remember)("packageName", () => {
+    const packageJSON = JSON.parse((0, node_fs_1.readFileSync)("package.json").toString());
+    return packageJSON.name;
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./configuration.js";
+export * from "./introspection.js";
+export * from "./test-helpers.js";
+export * from "./workloads.js";

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./configuration.js"), exports);
+__exportStar(require("./introspection.js"), exports);
+__exportStar(require("./test-helpers.js"), exports);
+__exportStar(require("./workloads.js"), exports);

package/dist/cjs/introspection.d.ts

@@ -0,0 +1,2 @@
+export { packageVersion, projectDependencies, projectDependency, projectFramework, projectName, } from "./scan/project.js";
+export { manifestJsonSchema, type BucketInfo, type BuildManifest, type CronInfo as CronInto, type DatabaseWorkloadInfo, type TaskInfo, type WorkloadInfo, } from "./make/manifest.js";

package/dist/cjs/introspection.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifestJsonSchema = exports.projectName = exports.projectFramework = exports.projectDependency = exports.projectDependencies = exports.packageVersion = void 0;
+var project_js_1 = require("./scan/project.js");
+Object.defineProperty(exports, "packageVersion", { enumerable: true, get: function () { return project_js_1.packageVersion; } });
+Object.defineProperty(exports, "projectDependencies", { enumerable: true, get: function () { return project_js_1.projectDependencies; } });
+Object.defineProperty(exports, "projectDependency", { enumerable: true, get: function () { return project_js_1.projectDependency; } });
+Object.defineProperty(exports, "projectFramework", { enumerable: true, get: function () { return project_js_1.projectFramework; } });
+Object.defineProperty(exports, "projectName", { enumerable: true, get: function () { return project_js_1.projectName; } });
+var manifest_js_1 = require("./make/manifest.js");
+Object.defineProperty(exports, "manifestJsonSchema", { enumerable: true, get: function () { return manifest_js_1.manifestJsonSchema; } });

package/dist/cjs/make/broadcast.d.ts

@@ -0,0 +1,10 @@
+import type { WorkloadImport } from "../scan/workload-imports.js";
+export declare function makeBroadcast(broadcastImport: WorkloadImport<unknown>): Promise<{
+    path: string;
+    entryPoint: string;
+    dockerfileName: string;
+}>;
+export declare function broadcastRequiredFiles(info: {
+    path: string;
+    entryPoint: string;
+}): Promise<void>;

package/dist/cjs/make/broadcast.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBroadcast = makeBroadcast;
+exports.broadcastRequiredFiles = broadcastRequiredFiles;
+const case_anything_1 = require("case-anything");
+const path_1 = __importDefault(require("path"));
+const tsup_1 = require("tsup");
+const config_js_1 = require("../make/config.js");
+const required_filtes_js_1 = require("../make/required-filtes.js");
+async function makeBroadcast(broadcastImport) {
+    const workloadId = (0, case_anything_1.kebabCase)("broadcast");
+    const dir = `broadcast/${workloadId}`;
+    const broadcastFileName = await buildBroadcast(broadcastImport, dir);
+    return {
+        path: dir,
+        entryPoint: broadcastFileName,
+        dockerfileName: "none",
+    };
+}
+async function buildBroadcast(broadcastImport, dir) {
+    const config = (0, config_js_1.tsupConfig)({ index: broadcastImport.src }, `.workloads/${dir}`, [/(.*)/], ".cjs");
+    // config.noExternal = [
+    // 	"@monolayer/sdk",
+    // 	"case-anything",
+    // 	"@epic-web/remember",
+    // 	"cron-parser",
+    // ];
+    await (0, tsup_1.build)(config);
+    return "index.mjs";
+}
+async function broadcastRequiredFiles(info) {
+    const taskPath = path_1.default.join(".workloads", info.path, info.entryPoint);
+    await (0, required_filtes_js_1.requiredFiles)(taskPath);
+}

package/dist/cjs/make/config.d.ts

@@ -0,0 +1,2 @@
+import type { Options } from "tsup";
+export declare function tsupConfig(entry: string[] | Record<string, string>, outDir: string, noExternal: (string | RegExp)[], cjsExt?: string): Options;

package/dist/cjs/make/config.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsupConfig = tsupConfig;
+function tsupConfig(entry, outDir, noExternal, cjsExt = ".js") {
+    const options = {
+        outExtension({ format }) {
+            switch (format) {
+                case "cjs":
+                    return {
+                        js: cjsExt,
+                    };
+                case "iife":
+                    return {
+                        js: ".global.js",
+                    };
+                case "esm":
+                    return {
+                        js: ".mjs",
+                    };
+            }
+        },
+        format: ["esm"],
+        banner: {
+            js: `import { createRequire } from 'module'; const require = createRequire(import.meta.url);`,
+        },
+        entry,
+        outDir,
+        dts: false,
+        shims: true,
+        skipNodeModulesBundle: true,
+        noExternal: undefined,
+        bundle: true,
+        clean: false,
+        target: "node22",
+        platform: "node",
+        minify: false,
+        splitting: false,
+        treeshake: true,
+        cjsInterop: false,
+        sourcemap: true,
+        silent: true,
+    };
+    return options;
+}

package/dist/cjs/make/cron.d.ts

@@ -0,0 +1,9 @@
+import type { CronInfo } from "../make/manifest.js";
+import type { WorkloadImport } from "../scan/workload-imports.js";
+import type { Cron } from "../workloads/stateless/cron.js";
+export declare function makeCron(cronImport: WorkloadImport<Cron>): Promise<{
+    path: string;
+    entryPoint: string;
+    dockerfileName: string;
+}>;
+export declare function cronRequiredFiles(taskInfo: CronInfo): Promise<void>;

package/dist/cjs/make/cron.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCron = makeCron;
+exports.cronRequiredFiles = cronRequiredFiles;
+const case_anything_1 = require("case-anything");
+const path_1 = __importDefault(require("path"));
+const tsup_1 = require("tsup");
+const config_js_1 = require("../make/config.js");
+const required_filtes_js_1 = require("../make/required-filtes.js");
+async function makeCron(cronImport) {
+    const dir = `crons/${(0, case_anything_1.kebabCase)(cronImport.workload.id)}`;
+    const cronFileName = await buildCron(cronImport, dir);
+    return {
+        path: dir,
+        entryPoint: cronFileName,
+        dockerfileName: "none",
+    };
+}
+async function buildCron(cronImport, dir) {
+    const ext = ".cjs";
+    await (0, tsup_1.build)((0, config_js_1.tsupConfig)({ index: cronImport.src }, `.workloads/${dir}`, [/(.*)/], ext));
+    return `index.mjs`;
+}
+async function cronRequiredFiles(taskInfo) {
+    const cronPath = path_1.default.join(".workloads", taskInfo.path, taskInfo.entryPoint);
+    await (0, required_filtes_js_1.requiredFiles)(cronPath);
+}

package/dist/cjs/make/make.d.ts

@@ -0,0 +1,6 @@
+import type { WorkloadImports } from "../scan/workload-imports.js";
+export declare class Make {
+    #private;
+    constructor(workloads: WorkloadImports);
+    build(): Promise<string>;
+}

package/dist/cjs/make/make.js

@@ -0,0 +1,134 @@
+"use strict";
+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 _Make_instances, _Make_imports, _Make_collectWorkloads, _Make_addDatabase, _Make_writeManifestFile, _Make_writeSchemaFile, _Make_buildDir_get, _Make_setupBuildDirectory, _Make_initManifest;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Make = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+const broadcast_js_1 = require("../make/broadcast.js");
+const cron_js_1 = require("../make/cron.js");
+const manifest_js_1 = require("../make/manifest.js");
+const task_js_1 = require("../make/task.js");
+const project_js_1 = require("../scan/project.js");
+class Make {
+    constructor(workloads) {
+        _Make_instances.add(this);
+        _Make_imports.set(this, void 0);
+        __classPrivateFieldSet(this, _Make_imports, workloads, "f");
+    }
+    async build() {
+        __classPrivateFieldGet(this, _Make_instances, "m", _Make_setupBuildDirectory).call(this);
+        const manifest = await __classPrivateFieldGet(this, _Make_instances, "m", _Make_collectWorkloads).call(this);
+        const manifestFilePath = __classPrivateFieldGet(this, _Make_instances, "m", _Make_writeManifestFile).call(this, manifest);
+        __classPrivateFieldGet(this, _Make_instances, "m", _Make_writeSchemaFile).call(this);
+        return manifestFilePath;
+    }
+}
+exports.Make = Make;
+_Make_imports = new WeakMap(), _Make_instances = new WeakSet(), _Make_collectWorkloads = async function _Make_collectWorkloads() {
+    const manifest = await __classPrivateFieldGet(this, _Make_instances, "m", _Make_initManifest).call(this);
+    for (const imported of __classPrivateFieldGet(this, _Make_imports, "f").Redis) {
+        manifest.redis.push({
+            id: imported.workload.id,
+            connectionStringEnvVar: imported.workload.connectionStringEnvVar,
+        });
+    }
+    for (const imported of __classPrivateFieldGet(this, _Make_imports, "f").Bucket) {
+        manifest.bucket.push({
+            id: imported.workload.id,
+            publicAccess: imported.workload.publicAccess,
+        });
+    }
+    for (const imported of [...__classPrivateFieldGet(this, _Make_imports, "f").PostgresDatabase]) {
+        __classPrivateFieldGet(this, _Make_instances, "m", _Make_addDatabase).call(this, imported.workload, manifest.postgresDatabase);
+    }
+    for (const imported of __classPrivateFieldGet(this, _Make_imports, "f").Cron) {
+        const info = await (0, cron_js_1.makeCron)(imported);
+        const cronInfo = {
+            id: imported.workload.id,
+            entryPoint: info.entryPoint,
+            path: info.path,
+            schedule: imported.workload.schedule,
+        };
+        manifest.cron.push(cronInfo);
+        await (0, task_js_1.taskRequiredFiles)(cronInfo);
+    }
+    for (const imported of __classPrivateFieldGet(this, _Make_imports, "f").Task) {
+        const info = await (0, task_js_1.makeTask)(imported);
+        const taskInfo = {
+            id: imported.workload.name,
+            entryPoint: info.entryPoint,
+            path: info.path,
+        };
+        manifest.task.push(taskInfo);
+        await (0, task_js_1.taskRequiredFiles)(taskInfo);
+    }
+    if (__classPrivateFieldGet(this, _Make_imports, "f").Broadcast.length === 1) {
+        const info = await (0, broadcast_js_1.makeBroadcast)(__classPrivateFieldGet(this, _Make_imports, "f").Broadcast[0]);
+        manifest.broadcast = {
+            id: "broadcast",
+            path: info.path,
+            entryPoint: info.entryPoint,
+        };
+        await (0, broadcast_js_1.broadcastRequiredFiles)(info);
+    }
+    return manifest;
+}, _Make_addDatabase = function _Make_addDatabase(workload, info) {
+    const dbInfo = {
+        name: workload.databaseName,
+        connectionStringEnvVar: workload.connectionStringEnvVar,
+    };
+    const existingDb = info.find((d) => d.id === workload.id);
+    if (existingDb) {
+        return;
+    }
+    else {
+        info.push({
+            id: workload.id,
+            databases: [dbInfo],
+        });
+    }
+}, _Make_writeManifestFile = function _Make_writeManifestFile(manifest) {
+    const filePath = node_path_1.default.join(__classPrivateFieldGet(this, _Make_instances, "a", _Make_buildDir_get), "manifest.json");
+    (0, node_fs_1.writeFileSync)(filePath, JSON.stringify(manifest, null, 2));
+    return filePath;
+}, _Make_writeSchemaFile = function _Make_writeSchemaFile() {
+    const filePath = node_path_1.default.join(__classPrivateFieldGet(this, _Make_instances, "a", _Make_buildDir_get), "schema.json");
+    (0, node_fs_1.writeFileSync)(filePath, JSON.stringify(manifest_js_1.manifestJsonSchema, null, 2));
+}, _Make_buildDir_get = function _Make_buildDir_get() {
+    return node_path_1.default.join((0, node_process_1.cwd)(), ".workloads");
+}, _Make_setupBuildDirectory = function _Make_setupBuildDirectory() {
+    if ((0, node_fs_1.existsSync)(__classPrivateFieldGet(this, _Make_instances, "a", _Make_buildDir_get))) {
+        (0, node_fs_1.rmSync)(__classPrivateFieldGet(this, _Make_instances, "a", _Make_buildDir_get), {
+            recursive: true,
+            force: true,
+        });
+    }
+    (0, node_fs_1.mkdirSync)(__classPrivateFieldGet(this, _Make_instances, "a", _Make_buildDir_get));
+}, _Make_initManifest = async function _Make_initManifest() {
+    const manifest = {
+        version: "2",
+        framework: (await (0, project_js_1.projectFramework)()) ?? "",
+        postgresDatabase: [],
+        redis: [],
+        bucket: [],
+        cron: [],
+        task: [],
+        broadcast: {},
+    };
+    return manifest;
+};

package/dist/cjs/make/manifest.d.ts

@@ -0,0 +1,202 @@
+export interface BuildManifest {
+    version: string;
+    framework: string;
+    postgresDatabase: DatabaseWorkloadInfo[];
+    redis: WorkloadInfo[];
+    bucket: BucketInfo[];
+    cron: CronInfo[];
+    task: TaskInfo[];
+    broadcast: {
+        id: string;
+        path: string;
+        entryPoint: string;
+    } | object;
+}
+export interface DatabaseWorkloadInfo {
+    id: string;
+    databases: {
+        name: string;
+        connectionStringEnvVar: string;
+    }[];
+}
+export interface WorkloadInfo {
+    id: string;
+    connectionStringEnvVar: string;
+}
+export interface BucketInfo {
+    id: string;
+    publicAccess: Record<string, string[]>;
+}
+export interface CronInfo {
+    id: string;
+    path: string;
+    entryPoint: string;
+    schedule: string;
+}
+export interface TaskInfo {
+    id: string;
+    path: string;
+    entryPoint: string;
+}
+export declare const manifestJsonSchema: {
+    $schema: string;
+    type: string;
+    $id: string;
+    title: string;
+    properties: {
+        version: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        framework: {
+            type: string;
+            description: string;
+        };
+        postgresDatabase: {
+            type: string;
+            items: {
+                $ref: string;
+            };
+        };
+        mySqlDatabase: {
+            type: string;
+            items: {
+                $ref: string;
+            };
+        };
+        redis: {
+            type: string;
+            items: {
+                $ref: string;
+            };
+        };
+        bucket: {
+            type: string;
+            items: {
+                $ref: string;
+                description: string;
+            };
+        };
+        cron: {
+            type: string;
+            items: {
+                $ref: string;
+                description: string;
+            };
+        };
+        task: {
+            type: string;
+            items: {
+                $ref: string;
+                description: string;
+            };
+        };
+        broadcast: {
+            type: string;
+            id: {
+                type: string;
+            };
+            path: {
+                type: string;
+            };
+            entryPoint: {
+                type: string;
+            };
+        };
+    };
+    required: string[];
+    optional: string[];
+    $defs: {
+        DatabaseWorkloadInfo: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                databases: {
+                    type: string;
+                    items: {
+                        $ref: string;
+                    };
+                };
+            };
+            required: string[];
+        };
+        Database: {
+            type: string;
+            properties: {
+                name: {
+                    type: string;
+                };
+                connectionStringEnvVar: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+        WorkloadInfo: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                connectionStringEnvVar: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+        BucketInfo: {
+            type: string;
+            properties: {
+                name: {
+                    type: string;
+                };
+                private: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+        CronInfo: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                path: {
+                    type: string;
+                };
+                entryPoint: {
+                    type: string;
+                };
+                schedule: {
+                    type: string;
+                };
+                dockerfile: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+        TaskInfo: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                path: {
+                    type: string;
+                };
+                entryPoint: {
+                    type: string;
+                };
+                dockerfile: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+};