@monolayer/sdk 1.2.0-canary.4

package/dist/esm/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/esm/introspection.js

@@ -0,0 +1,2 @@
+export { packageVersion, projectDependencies, projectDependency, projectFramework, projectName, } from "./scan/project.js";
+export { manifestJsonSchema, } from "./make/manifest.js";

package/dist/esm/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/esm/make/broadcast.js

@@ -0,0 +1,30 @@
+import { kebabCase } from "case-anything";
+import path from "path";
+import { build } from "tsup";
+import { tsupConfig } from "../make/config.js";
+import { requiredFiles } from "../make/required-filtes.js";
+export async function makeBroadcast(broadcastImport) {
+    const workloadId = 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 = tsupConfig({ index: broadcastImport.src }, `.workloads/${dir}`, [/(.*)/], ".cjs");
+    // config.noExternal = [
+    // 	"@monolayer/sdk",
+    // 	"case-anything",
+    // 	"@epic-web/remember",
+    // 	"cron-parser",
+    // ];
+    await build(config);
+    return "index.mjs";
+}
+export async function broadcastRequiredFiles(info) {
+    const taskPath = path.join(".workloads", info.path, info.entryPoint);
+    await requiredFiles(taskPath);
+}

package/dist/esm/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/esm/make/config.js

@@ -0,0 +1,41 @@
+export 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/esm/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/esm/make/cron.js

@@ -0,0 +1,23 @@
+import { kebabCase } from "case-anything";
+import path from "path";
+import { build } from "tsup";
+import { tsupConfig } from "../make/config.js";
+import { requiredFiles } from "../make/required-filtes.js";
+export async function makeCron(cronImport) {
+    const dir = `crons/${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 build(tsupConfig({ index: cronImport.src }, `.workloads/${dir}`, [/(.*)/], ext));
+    return `index.mjs`;
+}
+export async function cronRequiredFiles(taskInfo) {
+    const cronPath = path.join(".workloads", taskInfo.path, taskInfo.entryPoint);
+    await requiredFiles(cronPath);
+}

package/dist/esm/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/esm/make/make.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { cwd } from "node:process";
+import { broadcastRequiredFiles, makeBroadcast, } from "../make/broadcast.js";
+import { makeCron } from "../make/cron.js";
+import { manifestJsonSchema, } from "../make/manifest.js";
+import { makeTask, taskRequiredFiles } from "../make/task.js";
+import { projectFramework } from "../scan/project.js";
+export class Make {
+    #imports;
+    constructor(workloads) {
+        this.#imports = workloads;
+    }
+    async build() {
+        this.#setupBuildDirectory();
+        const manifest = await this.#collectWorkloads();
+        const manifestFilePath = this.#writeManifestFile(manifest);
+        this.#writeSchemaFile();
+        return manifestFilePath;
+    }
+    async #collectWorkloads() {
+        const manifest = await this.#initManifest();
+        for (const imported of this.#imports.Redis) {
+            manifest.redis.push({
+                id: imported.workload.id,
+                connectionStringEnvVar: imported.workload.connectionStringEnvVar,
+            });
+        }
+        for (const imported of this.#imports.Bucket) {
+            manifest.bucket.push({
+                id: imported.workload.id,
+                publicAccess: imported.workload.publicAccess,
+            });
+        }
+        for (const imported of [...this.#imports.PostgresDatabase]) {
+            this.#addDatabase(imported.workload, manifest.postgresDatabase);
+        }
+        for (const imported of this.#imports.Cron) {
+            const info = await makeCron(imported);
+            const cronInfo = {
+                id: imported.workload.id,
+                entryPoint: info.entryPoint,
+                path: info.path,
+                schedule: imported.workload.schedule,
+            };
+            manifest.cron.push(cronInfo);
+            await taskRequiredFiles(cronInfo);
+        }
+        for (const imported of this.#imports.Task) {
+            const info = await makeTask(imported);
+            const taskInfo = {
+                id: imported.workload.name,
+                entryPoint: info.entryPoint,
+                path: info.path,
+            };
+            manifest.task.push(taskInfo);
+            await taskRequiredFiles(taskInfo);
+        }
+        if (this.#imports.Broadcast.length === 1) {
+            const info = await makeBroadcast(this.#imports.Broadcast[0]);
+            manifest.broadcast = {
+                id: "broadcast",
+                path: info.path,
+                entryPoint: info.entryPoint,
+            };
+            await broadcastRequiredFiles(info);
+        }
+        return manifest;
+    }
+    #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],
+            });
+        }
+    }
+    #writeManifestFile(manifest) {
+        const filePath = path.join(this.#buildDir, "manifest.json");
+        writeFileSync(filePath, JSON.stringify(manifest, null, 2));
+        return filePath;
+    }
+    #writeSchemaFile() {
+        const filePath = path.join(this.#buildDir, "schema.json");
+        writeFileSync(filePath, JSON.stringify(manifestJsonSchema, null, 2));
+    }
+    get #buildDir() {
+        return path.join(cwd(), ".workloads");
+    }
+    #setupBuildDirectory() {
+        if (existsSync(this.#buildDir)) {
+            rmSync(this.#buildDir, {
+                recursive: true,
+                force: true,
+            });
+        }
+        mkdirSync(this.#buildDir);
+    }
+    async #initManifest() {
+        const manifest = {
+            version: "2",
+            framework: (await projectFramework()) ?? "",
+            postgresDatabase: [],
+            redis: [],
+            bucket: [],
+            cron: [],
+            task: [],
+            broadcast: {},
+        };
+        return manifest;
+    }
+}

package/dist/esm/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[];
+        };
+    };
+};

package/dist/esm/make/manifest.js

@@ -0,0 +1,162 @@
+export const manifestJsonSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    $id: "workloads-build-manifest-schema-v1",
+    title: "WorkloadsBuildManifest",
+    properties: {
+        version: {
+            type: "string",
+            enum: ["3"],
+            description: "The version of the schema. This must be '1' for version 1 of the schema.",
+        },
+        framework: {
+            type: "string",
+            description: "Application framework",
+        },
+        postgresDatabase: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/DatabaseWorkloadInfo",
+            },
+        },
+        mySqlDatabase: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/DatabaseWorkloadInfo",
+            },
+        },
+        redis: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/WorkloadInfo",
+            },
+        },
+        bucket: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/BucketInfo",
+                description: "Array of Bucket",
+            },
+        },
+        cron: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/CronInfo",
+                description: "Array of Cron",
+            },
+        },
+        task: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/TaskInfo",
+                description: "Array of Task",
+            },
+        },
+        broadcast: {
+            type: "string",
+            id: { type: "string" },
+            path: {
+                type: "string",
+            },
+            entryPoint: {
+                type: "string",
+            },
+        },
+    },
+    required: ["framework", "version"],
+    optional: [
+        "postgresDatabase",
+        "mysqlDatabase",
+        "redis",
+        "bucket",
+        "cron",
+        "task",
+        "broadcast",
+    ],
+    $defs: {
+        DatabaseWorkloadInfo: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+                databases: {
+                    type: "array",
+                    items: {
+                        $ref: "#/$defs/Database",
+                    },
+                },
+            },
+            required: ["id", "databases"],
+        },
+        Database: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                connectionStringEnvVar: { type: "string" },
+            },
+            required: ["name", "connectionStringEnvVar"],
+        },
+        WorkloadInfo: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                },
+                connectionStringEnvVar: {
+                    type: "string",
+                },
+            },
+            required: ["id", "connectionStringEnvVar"],
+        },
+        BucketInfo: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                private: {
+                    type: "boolean",
+                },
+            },
+            required: ["name"],
+        },
+        CronInfo: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                },
+                path: {
+                    type: "string",
+                },
+                entryPoint: {
+                    type: "string",
+                },
+                schedule: {
+                    type: "string",
+                },
+                dockerfile: {
+                    type: "string",
+                },
+            },
+            required: ["id", "path", "entryPoint", "schedule", "dockerfile"],
+        },
+        TaskInfo: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                },
+                path: {
+                    type: "string",
+                },
+                entryPoint: {
+                    type: "string",
+                },
+                dockerfile: {
+                    type: "string",
+                },
+            },
+            required: ["id", "path", "entryPoint", "dockerfile"],
+        },
+    },
+};

package/dist/esm/make/required-filtes.d.ts

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

package/dist/esm/make/required-filtes.js

@@ -0,0 +1,11 @@
+import { nodeFileTrace } from "@vercel/nft";
+import { writeFileSync } from "fs";
+import path from "path";
+export async function requiredFiles(filePath) {
+    const { fileList } = await nodeFileTrace([filePath]);
+    const requiredFilesPath = path.join(path.dirname(filePath), "required-files.json");
+    writeFileSync(requiredFilesPath, JSON.stringify({
+        version: "1",
+        files: Array.from(fileList).filter((f) => f !== filePath),
+    }, null, 2));
+}

package/dist/esm/make/task.d.ts

@@ -0,0 +1,9 @@
+import type { TaskInfo } from "../make/manifest.js";
+import type { WorkloadImport } from "../scan/workload-imports.js";
+import type { Task } from "../workloads/stateless/task/task.js";
+export declare function makeTask(taskImport: WorkloadImport<Task<unknown>>): Promise<{
+    path: string;
+    entryPoint: string;
+    dockerfileName: string;
+}>;
+export declare function taskRequiredFiles(taskInfo: TaskInfo): Promise<void>;

package/dist/esm/make/task.js

@@ -0,0 +1,23 @@
+import { kebabCase } from "case-anything";
+import path from "path";
+import { build } from "tsup";
+import { tsupConfig } from "../make/config.js";
+import { requiredFiles } from "../make/required-filtes.js";
+export async function makeTask(taskImport) {
+    const workloadId = kebabCase(taskImport.workload.name);
+    const dir = `tasks/${workloadId}`;
+    const taskFileName = await buildTask(taskImport, dir);
+    return {
+        path: dir,
+        entryPoint: taskFileName,
+        dockerfileName: "none",
+    };
+}
+async function buildTask(taskImport, dir) {
+    await build(tsupConfig({ index: taskImport.src }, `.workloads/${dir}`, [/(.*)/], ".cjs"));
+    return "index.mjs";
+}
+export async function taskRequiredFiles(taskInfo) {
+    const taskPath = path.join(".workloads", taskInfo.path, taskInfo.entryPoint);
+    await requiredFiles(taskPath);
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}