@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/packages/utils/playground.js

@@ -0,0 +1,35 @@
+"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;
+};
+async function main() {
+    const filePath = "./2323.js";
+    return await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
+}
+main()
+    .then((r) => console.dir(r, { depth: null }))
+    .catch((e) => {
+    console.log("ERROR", e instanceof Error);
+    console.dir(e, { depth: null });
+});
+//# sourceMappingURL=playground.js.map

package/dist/cjs/scaffolding/add-env-var.d.ts

@@ -0,0 +1,6 @@
+export declare function addEnvVar(name: string, value: string): Promise<void>;
+export declare function updateDotenvFile(vars?: {
+    name: string;
+    value: string;
+}[]): Promise<void>;
+export declare function dotenvFile(): Promise<string>;

package/dist/cjs/scaffolding/add-env-var.js

@@ -0,0 +1,65 @@
+"use strict";
+// ML_PG_KLAMP_DB_DATABASE_URL="postgresql://postgres:postgres@localhost:5432/klamp-db"
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addEnvVar = addEnvVar;
+exports.updateDotenvFile = updateDotenvFile;
+exports.dotenvFile = dotenvFile;
+const fs_1 = require("fs");
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const process_1 = require("process");
+const readline_1 = __importDefault(require("readline"));
+async function addEnvVar(name, value) {
+    const spinner = (0, ora_1.default)();
+    spinner.start("Adding environment variable to .env.local");
+    await updateDotenvFile([
+        {
+            name,
+            value,
+        },
+    ]);
+    spinner.succeed();
+}
+async function updateDotenvFile(vars = []) {
+    const envFilePath = path_1.default.join((0, process_1.cwd)(), ".env.local");
+    if (!(0, fs_1.existsSync)(envFilePath)) {
+        (0, fs_1.writeFileSync)(envFilePath, vars
+            .map((v) => {
+            return `${v.name}="${v.value}"`;
+        })
+            .join("\n"));
+        return;
+    }
+    const newContent = [];
+    const file = readline_1.default.createInterface({
+        input: (0, fs_1.createReadStream)(".env.local"),
+        output: process.stdout,
+        terminal: false,
+    });
+    const keys = vars.reduce((acc, val) => {
+        acc.push([val.name, new RegExp(`^${val.name}`), val.value]);
+        return acc;
+    }, []);
+    file.on("line", (line) => {
+        const idx = keys.findIndex((key) => line.trim().match(key[1]));
+        if (idx !== -1) {
+            const match = keys.splice(idx, 1)[0];
+            newContent.push(`${match[0]}="${match[2]}"`);
+        }
+        else {
+            newContent.push(line);
+        }
+    });
+    file.on("close", () => {
+        for (const key of keys) {
+            newContent.push(`${key[0]}="${key[2]}"`);
+        }
+        (0, fs_1.writeFileSync)(envFilePath, newContent.join("\n"));
+    });
+}
+async function dotenvFile() {
+    return ".env.local";
+}

package/dist/cjs/scaffolding/add-import.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adds a named import to a TypeScript file.
+ *
+ * @param filePath The path to the file to modify.
+ * @param moduleSpecifier The module to import from (e.g., "react").
+ * @param namedImport The named import to add (e.g., "useState").
+ */
+export declare function addImport(filePath: string, moduleSpecifier: string, namedImport: string): Promise<void>;
+/**
+ * Adds a named import to a TypeScript file.
+ *
+ * @param filePath The path to the file to modify.
+ * @param moduleSpecifier The module to import from (e.g., "react").
+ * @param defaultImport The default import to add.
+ */
+export declare function addDefaultImport(filePath: string, moduleSpecifier: string, defaultImport: string): Promise<void>;

package/dist/cjs/scaffolding/add-import.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImport = addImport;
+exports.addDefaultImport = addDefaultImport;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Adds a named import to a TypeScript file.
+ *
+ * @param filePath The path to the file to modify.
+ * @param moduleSpecifier The module to import from (e.g., "react").
+ * @param namedImport The named import to add (e.g., "useState").
+ */
+async function addImport(filePath, moduleSpecifier, namedImport) {
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    // This is a simple way to add an import.
+    // ts-morph is smart about merging with existing imports from the same module.
+    sourceFile.addImportDeclaration({
+        moduleSpecifier,
+        namedImports: [namedImport],
+    });
+    // Save the changes back to the file system.
+    await sourceFile.save();
+}
+/**
+ * Adds a named import to a TypeScript file.
+ *
+ * @param filePath The path to the file to modify.
+ * @param moduleSpecifier The module to import from (e.g., "react").
+ * @param defaultImport The default import to add.
+ */
+async function addDefaultImport(filePath, moduleSpecifier, defaultImport) {
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    // This is a simple way to add an import.
+    // ts-morph is smart about merging with existing imports from the same module.
+    sourceFile.addImportDeclaration({
+        moduleSpecifier,
+        defaultImport,
+    });
+    // Save the changes back to the file system.
+    await sourceFile.save();
+}

package/dist/cjs/scaffolding/add-script.d.ts

@@ -0,0 +1 @@
+export declare function addScriptToPackageJson(name: string, scriptValue: string): Promise<void>;

package/dist/cjs/scaffolding/add-script.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addScriptToPackageJson = addScriptToPackageJson;
+const fs_1 = require("fs");
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const process_1 = require("process");
+const prompts_1 = __importDefault(require("prompts"));
+async function addScriptToPackageJson(name, scriptValue) {
+    const packageJsonPath = path_1.default.join((0, process_1.cwd)(), "package.json");
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+    if (packageJson.scripts && packageJson.scripts[name]) {
+        const response = await (0, prompts_1.default)({
+            type: "confirm",
+            name: "overwrite",
+            message: `Script "${name}" already exists. Overwrite?`,
+            initial: false,
+        });
+        if (!response.overwrite) {
+            console.log(`Script "${name}" not overwritten.`);
+            return;
+        }
+    }
+    packageJson.scripts = {
+        ...(packageJson.scripts || {}),
+        [name]: scriptValue,
+    };
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Add script ${name}`);
+    (0, fs_1.writeFileSync)(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    spinner.succeed();
+}

package/dist/cjs/scaffolding/broadcast-workload.d.ts

@@ -0,0 +1 @@
+export declare function addBroadcastWorkload(): void;

package/dist/cjs/scaffolding/broadcast-workload.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBroadcastWorkload = addBroadcastWorkload;
+const ora_1 = __importDefault(require("ora"));
+const workload_js_1 = require("./workload.js");
+function addBroadcastWorkload() {
+    const template = broadcastWorkload();
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create broadcast workload in ./workloads/broadcast.ts`);
+    (0, workload_js_1.writeWorkload)("broadcast", template);
+    spinner.succeed();
+}
+function broadcastWorkload() {
+    return `import { Broadcast, ChannelData } from "@monolayer/sdk";
+
+export type SampleChannelData = { message: string };
+export type RoomChannelData = { message: string };
+
+const broadcast = new Broadcast({
+	channels: {
+		"sample": {
+			data: new ChannelData<SampleChannelData>(),
+		},
+		"/room/:id": {
+			data: new ChannelData<RoomChannelData>(),
+		},
+	},
+});
+
+export default broadcast;
+export type Channels = typeof broadcast._channelDataType;
+`;
+}

package/dist/cjs/scaffolding/bucket-workload.d.ts

@@ -0,0 +1,6 @@
+type Bucket = {
+    id: string;
+    name: string;
+};
+export declare function addBucketWorkload(bucket: Bucket): void;
+export {};

package/dist/cjs/scaffolding/bucket-workload.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBucketWorkload = addBucketWorkload;
+const ora_1 = __importDefault(require("ora"));
+const workload_js_1 = require("./workload.js");
+function addBucketWorkload(bucket) {
+    const template = bucketWorkload(bucket);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create bucket workload in ./workloads/${bucket.id}.ts`);
+    (0, workload_js_1.writeWorkload)(bucket.id, template);
+    spinner.succeed();
+}
+function bucketWorkload(bucket) {
+    return `import { Bucket } from "@monolayer/sdk";
+
+const ${bucket.name} = new Bucket("${bucket.id}");
+
+export default ${bucket.name};
+`;
+}

package/dist/cjs/scaffolding/cron-workload.d.ts

@@ -0,0 +1,6 @@
+type Cron = {
+    id: string;
+    name: string;
+};
+export declare function addCronWorkload(cron: Cron): void;
+export {};

package/dist/cjs/scaffolding/cron-workload.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCronWorkload = addCronWorkload;
+const ora_1 = __importDefault(require("ora"));
+const workload_js_1 = require("./workload.js");
+function addCronWorkload(cron) {
+    const template = cronWorkload(cron);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create cron workload in ./workloads/${cron.id}.ts`);
+    (0, workload_js_1.writeWorkload)(cron.id, template);
+    spinner.succeed();
+}
+function cronWorkload(task) {
+    return `import { Cron } from "@monolayer/sdk";
+
+const ${task.name} = new Cron("${task.id}", {
+	schedule: "* * * * *",
+	run: async () => {
+		console.log("Hello, world!");
+	},
+});
+
+export default ${task.name};
+`;
+}

package/dist/cjs/scaffolding/drizzle.d.ts

@@ -0,0 +1,4 @@
+export declare function addDrizzlePostgres(opts: {
+    id: string;
+    name: string;
+}): Promise<void>;

package/dist/cjs/scaffolding/drizzle.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDrizzlePostgres = addDrizzlePostgres;
+const child_process_1 = require("child_process");
+const workloads_js_1 = require("../workloads.js");
+const add_env_var_js_1 = require("./add-env-var.js");
+const add_script_js_1 = require("./add-script.js");
+const postgres_database_workload_js_1 = require("./postgres-database-workload.js");
+const registryJSON = "https://registry.monolayer.dev/r/drizzle-pg.json";
+async function addDrizzlePostgres(opts) {
+    (0, child_process_1.execSync)(`npx shadcn@latest add ${registryJSON}`, { stdio: "inherit" });
+    (0, postgres_database_workload_js_1.addPostgresWorkload)(opts);
+    await (0, postgres_database_workload_js_1.addDefaultImports)(opts, {
+        rootConfigFile: "drizzle.config.ts",
+        clientFile: "lib/drizzle/drizzle.ts",
+    });
+    await (0, add_env_var_js_1.addEnvVar)(new workloads_js_1.PostgresDatabase(opts.id).connectionStringEnvVar, `postgresql://postgres:postgres@localhost:5432/${opts.id}`);
+    await (0, add_script_js_1.addScriptToPackageJson)("db:generate", "drizzle-kit generate");
+    await (0, add_script_js_1.addScriptToPackageJson)("db:migrate", "npx tsx lib/drizzle/migrate.ts");
+    await (0, add_script_js_1.addScriptToPackageJson)("db:seed", "npx tsx lib/drizzle/seed.ts");
+    await (0, add_script_js_1.addScriptToPackageJson)("db:studio", "drizzle-kit studio");
+}

package/dist/cjs/scaffolding/lifecycle.d.ts

@@ -0,0 +1,9 @@
+type Lifecycle = {
+    id: string;
+    name: string;
+    scriptName: string;
+};
+export declare function addBeforeRolloutWorkload(lifecycle: Lifecycle): void;
+export declare function addAfterRolloutWorkload(lifecycle: Lifecycle): void;
+export declare function addBootstrapWorkload(lifecycle: Lifecycle): void;
+export {};

package/dist/cjs/scaffolding/lifecycle.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBeforeRolloutWorkload = addBeforeRolloutWorkload;
+exports.addAfterRolloutWorkload = addAfterRolloutWorkload;
+exports.addBootstrapWorkload = addBootstrapWorkload;
+const ora_1 = __importDefault(require("ora"));
+const workload_js_1 = require("./workload.js");
+function addBeforeRolloutWorkload(lifecycle) {
+    const template = beforeRolloutWorkload(lifecycle);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create before rollout workload in ./workloads/${lifecycle.id}.ts`);
+    (0, workload_js_1.writeWorkload)(`before-rollout-${lifecycle.id}`, template);
+    spinner.succeed();
+}
+function beforeRolloutWorkload(lifecycle) {
+    return `import { BeforeRollout } from "@monolayer/sdk";
+
+const ${lifecycle.name} = new BeforeRollout("${lifecycle.id}", {
+	script: "${lifecycle.scriptName}",
+});
+
+export default ${lifecycle.name};
+`;
+}
+function addAfterRolloutWorkload(lifecycle) {
+    const template = afterRolloutWorkload(lifecycle);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create after rollout workload in ./workloads/${lifecycle.id}.ts`);
+    (0, workload_js_1.writeWorkload)(`after-rollout-${lifecycle.id}`, template);
+    spinner.succeed();
+}
+function afterRolloutWorkload(lifecycle) {
+    return `import { AfterRollout } from "@monolayer/sdk";
+
+const ${lifecycle.name} = new AfterRollout("${lifecycle.id}", {
+	script: "${lifecycle.scriptName}",
+});
+
+export default ${lifecycle.name};
+`;
+}
+function addBootstrapWorkload(lifecycle) {
+    const template = boostrapWorkload(lifecycle);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create before rollout workload in ./workloads/${lifecycle.id}.ts`);
+    (0, workload_js_1.writeWorkload)(`bootstrap-${lifecycle.id}`, template);
+    spinner.succeed();
+}
+function boostrapWorkload(lifecycle) {
+    return `import { Bootstrap } from "@monolayer/sdk";
+
+const ${lifecycle.name} = new Bootstrap("${lifecycle.id}", {
+	script: "${lifecycle.scriptName}",
+});
+
+export default ${lifecycle.name};
+`;
+}

package/dist/cjs/scaffolding/postgres-database-workload.d.ts

@@ -0,0 +1,15 @@
+export declare function postgresDatabaseWorkload(opts: {
+    id: string;
+    name: string;
+}): string;
+export declare function addPostgresWorkload(opts: {
+    name: string;
+    id: string;
+}): void;
+export declare function addDefaultImports(opts: {
+    id: string;
+    name: string;
+}, files: {
+    rootConfigFile: string;
+    clientFile: string;
+}): Promise<void>;

package/dist/cjs/scaffolding/postgres-database-workload.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postgresDatabaseWorkload = postgresDatabaseWorkload;
+exports.addPostgresWorkload = addPostgresWorkload;
+exports.addDefaultImports = addDefaultImports;
+const ora_1 = __importDefault(require("ora"));
+const add_import_js_1 = require("./add-import.js");
+const replace_string_js_1 = require("./replace-string.js");
+const workload_js_1 = require("./workload.js");
+function postgresDatabaseWorkload(opts) {
+    return `import { PostgresDatabase } from "@monolayer/sdk";
+
+const ${opts.name} = new PostgresDatabase("${opts.id}");
+
+export default ${opts.name};
+`;
+}
+function addPostgresWorkload(opts) {
+    const template = postgresDatabaseWorkload(opts);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create postgres workload in ./workloads/${opts.id}.ts`);
+    (0, workload_js_1.writeWorkload)(opts.id, template);
+    spinner.succeed();
+}
+async function addDefaultImports(opts, files) {
+    const spinner = (0, ora_1.default)();
+    spinner.start("Adapt configuration");
+    await (0, add_import_js_1.addDefaultImport)(files.rootConfigFile, `./workloads/${opts.id}`, "database");
+    await (0, add_import_js_1.addDefaultImport)(files.clientFile, `@/workloads/${opts.id}`, "database");
+    (0, replace_string_js_1.replaceStringWithIdendentifier)({
+        from: "DATABASE_URL",
+        to: "database.connectionStringEnvVar",
+        files: [files.rootConfigFile, files.clientFile],
+    });
+    spinner.succeed();
+}

package/dist/cjs/scaffolding/prisma.d.ts

@@ -0,0 +1,4 @@
+export declare function addPrismaPosgres(opts: {
+    id: string;
+    name: string;
+}): Promise<void>;

package/dist/cjs/scaffolding/prisma.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPrismaPosgres = addPrismaPosgres;
+const child_process_1 = require("child_process");
+const ora_1 = __importDefault(require("ora"));
+const process_1 = require("process");
+const workloads_js_1 = require("../workloads.js");
+const add_env_var_js_1 = require("./add-env-var.js");
+const add_script_js_1 = require("./add-script.js");
+const postgres_database_workload_js_1 = require("./postgres-database-workload.js");
+const registryJSON = "https://registry.monolayer.dev/r/prisma-pg.json";
+async function addPrismaPosgres(opts) {
+    (0, child_process_1.execSync)(`npx shadcn@latest add ${registryJSON}`, { stdio: "inherit" });
+    (0, postgres_database_workload_js_1.addPostgresWorkload)(opts);
+    await (0, postgres_database_workload_js_1.addDefaultImports)(opts, {
+        rootConfigFile: "prisma.config.ts",
+        clientFile: "lib/prisma/prisma.ts",
+    });
+    await (0, add_env_var_js_1.addEnvVar)(new workloads_js_1.PostgresDatabase(opts.id).connectionStringEnvVar, `postgresql://postgres:postgres@localhost:5432/${opts.id}`);
+    const spinner = (0, ora_1.default)();
+    await (0, add_script_js_1.addScriptToPackageJson)("db:migrate", "npx prisma migrate dev");
+    await (0, add_script_js_1.addScriptToPackageJson)("db:deploy", "npx prisma migrate deploy");
+    await (0, add_script_js_1.addScriptToPackageJson)("db:seed", "npx prisma db seed");
+    await (0, add_script_js_1.addScriptToPackageJson)("db:studio", "npx prisma studio");
+    spinner.start("Generate prisma client");
+    await new Promise((resolve) => setTimeout(() => resolve(), 1000));
+    try {
+        (0, child_process_1.execSync)("npx prisma generate", { stdio: "ignore" });
+        spinner.succeed();
+    }
+    catch (e) {
+        spinner.fail("Failed to generate prisma client");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        console.error(e);
+        (0, process_1.exit)(1);
+    }
+}

package/dist/cjs/scaffolding/replace-string.d.ts

@@ -0,0 +1,10 @@
+export declare function replaceString(opts: {
+    from: string;
+    to: string;
+    files: string[];
+}): void;
+export declare function replaceStringWithIdendentifier(opts: {
+    from: string;
+    to: string;
+    files: string[];
+}): void;

package/dist/cjs/scaffolding/replace-string.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.replaceString = replaceString;
+exports.replaceStringWithIdendentifier = replaceStringWithIdendentifier;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+function replaceString(opts) {
+    for (const file of opts.files) {
+        const filePath = path_1.default.join(process.cwd(), file);
+        try {
+            const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const newContent = content.replace(new RegExp(opts.from, "g"), opts.to);
+            (0, fs_1.writeFileSync)(filePath, newContent);
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            console.error(e.message);
+        }
+    }
+}
+function replaceStringWithIdendentifier(opts) {
+    for (const file of opts.files) {
+        const filePath = path_1.default.join(process.cwd(), file);
+        try {
+            const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const newContent = content.replace(new RegExp(`"${opts.from}"`, "g"), opts.to);
+            (0, fs_1.writeFileSync)(filePath, newContent);
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            console.error(e.message);
+        }
+    }
+}

package/dist/cjs/scaffolding/task-workload.d.ts

@@ -0,0 +1,6 @@
+type Task = {
+    id: string;
+    name: string;
+};
+export declare function addTaskWorkload(task: Task): void;
+export {};

package/dist/cjs/scaffolding/task-workload.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.addTaskWorkload = addTaskWorkload;
+const case_anything_1 = require("case-anything");
+const ora_1 = __importDefault(require("ora"));
+const workload_js_1 = require("./workload.js");
+function addTaskWorkload(task) {
+    const template = taskWorkload(task);
+    const spinner = (0, ora_1.default)();
+    spinner.start(`Create task workload in ./workloads/${task.id}.ts`);
+    (0, workload_js_1.writeWorkload)(task.id, template);
+    spinner.succeed();
+}
+function taskWorkload(task) {
+    return `import { Task } from "@monolayer/sdk";
+
+export type ${(0, case_anything_1.pascalCase)(task.name)}Data = {
+  message: string;
+}
+
+const ${task.name} = new Task<${(0, case_anything_1.pascalCase)(task.name)}Data>("${task.id}", async ({ data }) => {
+	console.log("message", data.message);
+});
+
+export default ${task.name};
+`;
+}

package/dist/cjs/scaffolding/workload.d.ts

@@ -0,0 +1 @@
+export declare function writeWorkload(name: string, content: string): void;

package/dist/cjs/scaffolding/workload.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeWorkload = writeWorkload;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+function writeWorkload(name, content) {
+    createWorkloadsDir();
+    (0, fs_1.writeFileSync)(path_1.default.join("workloads", `${name}.ts`), content);
+}
+function createWorkloadsDir() {
+    const dir = path_1.default.join("workloads");
+    if ((0, fs_1.existsSync)(dir))
+        return;
+    (0, fs_1.mkdirSync)(dir);
+}

package/dist/cjs/scan/project.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the project is dependant on a package.
+ */
+export declare function projectDependency(packageName: string, projectRoot?: string): boolean;
+/**
+ * Returns all project dependencies
+ */
+export declare function projectDependencies(projectRoot?: string): string[];
+/**
+ * Returns the project name (from package.json)
+ */
+export declare function projectName(projectRoot?: string): string | undefined;
+/**
+ * Returns the slug (unique identifier) of the framework
+ * used in the current project.
+ *
+ * Frameworks are defected wirth the package: `@vercel/fs-detectors`
+ */
+export declare function projectFramework(projectRoot?: string): Promise<string | undefined>;
+/**
+ * Returns the installed version of a package or `undefined` if the package is not installed.
+ */
+export declare function packageVersion(packageName: string, projectRoot?: string): Promise<string | undefined>;