@monolayer/sdk 1.2.0-canary.4

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

@@ -0,0 +1,39 @@
+import { Project } from "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").
+ */
+export async function addImport(filePath, moduleSpecifier, namedImport) {
+    const project = new 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.
+ */
+export async function addDefaultImport(filePath, moduleSpecifier, defaultImport) {
+    const project = new 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/esm/scaffolding/add-script.d.ts

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

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

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync } from "fs";
+import ora from "ora";
+import path from "path";
+import { cwd } from "process";
+import prompts from "prompts";
+export async function addScriptToPackageJson(name, scriptValue) {
+    const packageJsonPath = path.join(cwd(), "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.scripts && packageJson.scripts[name]) {
+        const response = await prompts({
+            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 = ora();
+    spinner.start(`Add script ${name}`);
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    spinner.succeed();
+}

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

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

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

@@ -0,0 +1,30 @@
+import ora from "ora";
+import { writeWorkload } from "./workload.js";
+export function addBroadcastWorkload() {
+    const template = broadcastWorkload();
+    const spinner = ora();
+    spinner.start(`Create broadcast workload in ./workloads/broadcast.ts`);
+    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/esm/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/esm/scaffolding/bucket-workload.js

@@ -0,0 +1,17 @@
+import ora from "ora";
+import { writeWorkload } from "./workload.js";
+export function addBucketWorkload(bucket) {
+    const template = bucketWorkload(bucket);
+    const spinner = ora();
+    spinner.start(`Create bucket workload in ./workloads/${bucket.id}.ts`);
+    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/esm/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/esm/scaffolding/cron-workload.js

@@ -0,0 +1,22 @@
+import ora from "ora";
+import { writeWorkload } from "./workload.js";
+export function addCronWorkload(cron) {
+    const template = cronWorkload(cron);
+    const spinner = ora();
+    spinner.start(`Create cron workload in ./workloads/${cron.id}.ts`);
+    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/esm/scaffolding/drizzle.d.ts

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

package/dist/esm/scaffolding/drizzle.js

@@ -0,0 +1,19 @@
+import { execSync } from "child_process";
+import { PostgresDatabase } from "../workloads.js";
+import { addEnvVar } from "./add-env-var.js";
+import { addScriptToPackageJson } from "./add-script.js";
+import { addDefaultImports, addPostgresWorkload, } from "./postgres-database-workload.js";
+const registryJSON = "https://registry.monolayer.dev/r/drizzle-pg.json";
+export async function addDrizzlePostgres(opts) {
+    execSync(`npx shadcn@latest add ${registryJSON}`, { stdio: "inherit" });
+    addPostgresWorkload(opts);
+    await addDefaultImports(opts, {
+        rootConfigFile: "drizzle.config.ts",
+        clientFile: "lib/drizzle/drizzle.ts",
+    });
+    await addEnvVar(new PostgresDatabase(opts.id).connectionStringEnvVar, `postgresql://postgres:postgres@localhost:5432/${opts.id}`);
+    await addScriptToPackageJson("db:generate", "drizzle-kit generate");
+    await addScriptToPackageJson("db:migrate", "npx tsx lib/drizzle/migrate.ts");
+    await addScriptToPackageJson("db:seed", "npx tsx lib/drizzle/seed.ts");
+    await addScriptToPackageJson("db:studio", "drizzle-kit studio");
+}

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

@@ -0,0 +1,53 @@
+import ora from "ora";
+import { writeWorkload } from "./workload.js";
+export function addBeforeRolloutWorkload(lifecycle) {
+    const template = beforeRolloutWorkload(lifecycle);
+    const spinner = ora();
+    spinner.start(`Create before rollout workload in ./workloads/${lifecycle.id}.ts`);
+    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};
+`;
+}
+export function addAfterRolloutWorkload(lifecycle) {
+    const template = afterRolloutWorkload(lifecycle);
+    const spinner = ora();
+    spinner.start(`Create after rollout workload in ./workloads/${lifecycle.id}.ts`);
+    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};
+`;
+}
+export function addBootstrapWorkload(lifecycle) {
+    const template = boostrapWorkload(lifecycle);
+    const spinner = ora();
+    spinner.start(`Create before rollout workload in ./workloads/${lifecycle.id}.ts`);
+    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/esm/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/esm/scaffolding/postgres-database-workload.js

@@ -0,0 +1,31 @@
+import ora from "ora";
+import { addDefaultImport } from "./add-import.js";
+import { replaceStringWithIdendentifier } from "./replace-string.js";
+import { writeWorkload } from "./workload.js";
+export function postgresDatabaseWorkload(opts) {
+    return `import { PostgresDatabase } from "@monolayer/sdk";
+
+const ${opts.name} = new PostgresDatabase("${opts.id}");
+
+export default ${opts.name};
+`;
+}
+export function addPostgresWorkload(opts) {
+    const template = postgresDatabaseWorkload(opts);
+    const spinner = ora();
+    spinner.start(`Create postgres workload in ./workloads/${opts.id}.ts`);
+    writeWorkload(opts.id, template);
+    spinner.succeed();
+}
+export async function addDefaultImports(opts, files) {
+    const spinner = ora();
+    spinner.start("Adapt configuration");
+    await addDefaultImport(files.rootConfigFile, `./workloads/${opts.id}`, "database");
+    await addDefaultImport(files.clientFile, `@/workloads/${opts.id}`, "database");
+    replaceStringWithIdendentifier({
+        from: "DATABASE_URL",
+        to: "database.connectionStringEnvVar",
+        files: [files.rootConfigFile, files.clientFile],
+    });
+    spinner.succeed();
+}

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

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

package/dist/esm/scaffolding/prisma.js

@@ -0,0 +1,34 @@
+import { execSync } from "child_process";
+import ora from "ora";
+import { exit } from "process";
+import { PostgresDatabase } from "../workloads.js";
+import { addEnvVar } from "./add-env-var.js";
+import { addScriptToPackageJson } from "./add-script.js";
+import { addDefaultImports, addPostgresWorkload, } from "./postgres-database-workload.js";
+const registryJSON = "https://registry.monolayer.dev/r/prisma-pg.json";
+export async function addPrismaPosgres(opts) {
+    execSync(`npx shadcn@latest add ${registryJSON}`, { stdio: "inherit" });
+    addPostgresWorkload(opts);
+    await addDefaultImports(opts, {
+        rootConfigFile: "prisma.config.ts",
+        clientFile: "lib/prisma/prisma.ts",
+    });
+    await addEnvVar(new PostgresDatabase(opts.id).connectionStringEnvVar, `postgresql://postgres:postgres@localhost:5432/${opts.id}`);
+    const spinner = ora();
+    await addScriptToPackageJson("db:migrate", "npx prisma migrate dev");
+    await addScriptToPackageJson("db:deploy", "npx prisma migrate deploy");
+    await addScriptToPackageJson("db:seed", "npx prisma db seed");
+    await addScriptToPackageJson("db:studio", "npx prisma studio");
+    spinner.start("Generate prisma client");
+    await new Promise((resolve) => setTimeout(() => resolve(), 1000));
+    try {
+        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);
+        exit(1);
+    }
+}

package/dist/esm/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/esm/scaffolding/replace-string.js

@@ -0,0 +1,30 @@
+import { readFileSync, writeFileSync } from "fs";
+import path from "path";
+export function replaceString(opts) {
+    for (const file of opts.files) {
+        const filePath = path.join(process.cwd(), file);
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            const newContent = content.replace(new RegExp(opts.from, "g"), opts.to);
+            writeFileSync(filePath, newContent);
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            console.error(e.message);
+        }
+    }
+}
+export function replaceStringWithIdendentifier(opts) {
+    for (const file of opts.files) {
+        const filePath = path.join(process.cwd(), file);
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            const newContent = content.replace(new RegExp(`"${opts.from}"`, "g"), opts.to);
+            writeFileSync(filePath, newContent);
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            console.error(e.message);
+        }
+    }
+}

package/dist/esm/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/esm/scaffolding/task-workload.js

@@ -0,0 +1,24 @@
+import { pascalCase } from "case-anything";
+import ora from "ora";
+import { writeWorkload } from "./workload.js";
+export function addTaskWorkload(task) {
+    const template = taskWorkload(task);
+    const spinner = ora();
+    spinner.start(`Create task workload in ./workloads/${task.id}.ts`);
+    writeWorkload(task.id, template);
+    spinner.succeed();
+}
+function taskWorkload(task) {
+    return `import { Task } from "@monolayer/sdk";
+
+export type ${pascalCase(task.name)}Data = {
+  message: string;
+}
+
+const ${task.name} = new Task<${pascalCase(task.name)}Data>("${task.id}", async ({ data }) => {
+	console.log("message", data.message);
+});
+
+export default ${task.name};
+`;
+}

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

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

package/dist/esm/scaffolding/workload.js

@@ -0,0 +1,12 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import path from "path";
+export function writeWorkload(name, content) {
+    createWorkloadsDir();
+    writeFileSync(path.join("workloads", `${name}.ts`), content);
+}
+function createWorkloadsDir() {
+    const dir = path.join("workloads");
+    if (existsSync(dir))
+        return;
+    mkdirSync(dir);
+}

package/dist/esm/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>;

package/dist/esm/scan/project.js

@@ -0,0 +1,69 @@
+import { frameworkList } from "@vercel/frameworks";
+import { detectFrameworks, LocalFileSystemDetector, } from "@vercel/fs-detectors";
+import { readFileSync } from "fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { cwd } from "node:process";
+/**
+ * Returns true if the project is dependant on a package.
+ */
+export function projectDependency(packageName, projectRoot) {
+    return projectDependencies(projectRoot).some((dep) => dep === packageName);
+}
+/**
+ * Returns all project dependencies
+ */
+export function projectDependencies(projectRoot) {
+    const packageJson = parsePackageJson(projectRoot);
+    return Object.keys(packageJson.dependencies ?? {});
+}
+/**
+ * Returns the project name (from package.json)
+ */
+export 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`
+ */
+export async function projectFramework(projectRoot) {
+    const result = await detectFrameworks({
+        fs: new LocalFileSystemDetector(projectRoot ?? cwd()),
+        frameworkList,
+    });
+    return result[0]?.slug ?? undefined;
+}
+function parsePackageJson(projectRoot) {
+    return JSON.parse(readFileSync(path.join(projectRoot ?? cwd(), "package.json")).toString());
+}
+/**
+ * Returns the installed version of a package or `undefined` if the package is not installed.
+ */
+export 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 = 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/esm/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;
+}