rwsdk 0.1.16 → 0.1.17

package/dist/scripts/debug-sync.mjs

@@ -0,0 +1,224 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { $ } from "execa";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import chokidar from "chokidar";
+import { lock } from "proper-lockfile";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const getPackageManagerInfo = (targetDir) => {
+    const pnpmResult = {
+        name: "pnpm",
+        lockFile: "pnpm-lock.yaml",
+        command: "add",
+    };
+    if (existsSync(path.join(targetDir, "yarn.lock"))) {
+        return { name: "yarn", lockFile: "yarn.lock", command: "add" };
+    }
+    if (existsSync(path.join(targetDir, "pnpm-lock.yaml"))) {
+        return pnpmResult;
+    }
+    if (existsSync(path.join(targetDir, "package-lock.json"))) {
+        return { name: "npm", lockFile: "package-lock.json", command: "install" };
+    }
+    return pnpmResult;
+};
+const performFullSync = async (sdkDir, targetDir) => {
+    console.log("📦 Packing SDK...");
+    const packResult = await $ `npm pack`;
+    const tarballName = packResult.stdout?.trim() ?? "";
+    if (!tarballName) {
+        console.error("❌ Failed to get tarball name from npm pack.");
+        return;
+    }
+    const tarballPath = path.resolve(sdkDir, tarballName);
+    console.log(`💿 Installing ${tarballName} in ${targetDir}...`);
+    const pm = getPackageManagerInfo(targetDir);
+    const packageJsonPath = path.join(targetDir, "package.json");
+    const lockfilePath = path.join(targetDir, pm.lockFile);
+    const originalPackageJson = await fs
+        .readFile(packageJsonPath, "utf-8")
+        .catch(() => null);
+    const originalLockfile = await fs
+        .readFile(lockfilePath, "utf-8")
+        .catch(() => null);
+    try {
+        const cmd = pm.name;
+        const args = [pm.command];
+        if (pm.name === "yarn") {
+            args.push(`file:${tarballPath}`);
+        }
+        else {
+            args.push(tarballPath);
+        }
+        await $(cmd, args, {
+            cwd: targetDir,
+            stdio: "inherit",
+        });
+    }
+    finally {
+        if (originalPackageJson) {
+            console.log("Restoring package.json...");
+            await fs.writeFile(packageJsonPath, originalPackageJson);
+        }
+        if (originalLockfile) {
+            console.log(`Restoring ${pm.lockFile}...`);
+            await fs.writeFile(lockfilePath, originalLockfile);
+        }
+        await fs.unlink(tarballPath).catch(() => {
+            // ignore if deletion fails
+        });
+    }
+};
+const performFastSync = async (sdkDir, targetDir) => {
+    console.log("⚡️ No dependency changes, performing fast sync...");
+    const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
+    const filesToSync = sdkPackageJson.files || [];
+    for (const file of filesToSync) {
+        const source = path.join(sdkDir, file);
+        const destination = path.join(targetDir, "node_modules/rwsdk", file);
+        if (existsSync(source)) {
+            await fs.cp(source, destination, { recursive: true, force: true });
+        }
+    }
+    // Always copy package.json
+    await fs.copyFile(path.join(sdkDir, "package.json"), path.join(targetDir, "node_modules/rwsdk/package.json"));
+};
+const performSync = async (sdkDir, targetDir) => {
+    console.log("🏗️  Rebuilding SDK...");
+    await $ `pnpm build`;
+    const sdkPackageJsonPath = path.join(sdkDir, "package.json");
+    const installedSdkPackageJsonPath = path.join(targetDir, "node_modules/rwsdk/package.json");
+    let packageJsonChanged = true;
+    if (existsSync(installedSdkPackageJsonPath)) {
+        const sdkPackageJsonContent = await fs.readFile(sdkPackageJsonPath, "utf-8");
+        const installedSdkPackageJsonContent = await fs.readFile(installedSdkPackageJsonPath, "utf-8");
+        if (sdkPackageJsonContent === installedSdkPackageJsonContent) {
+            packageJsonChanged = false;
+        }
+    }
+    if (packageJsonChanged) {
+        console.log("📦 package.json changed, performing full sync...");
+        await performFullSync(sdkDir, targetDir);
+    }
+    else {
+        await performFastSync(sdkDir, targetDir);
+    }
+    console.log("✅ Done syncing");
+};
+export const debugSync = async (opts) => {
+    const { targetDir, sdkDir = process.cwd(), watch } = opts;
+    if (!targetDir) {
+        console.error("❌ Please provide a target directory as an argument.");
+        process.exit(1);
+    }
+    // If not in watch mode, just do a one-time sync and exit.
+    if (!watch) {
+        await performSync(sdkDir, targetDir);
+        return;
+    }
+    // --- Watch Mode Logic ---
+    const lockfilePath = path.join(targetDir, "node_modules", ".rwsync.lock");
+    let release;
+    // Ensure the directory for the lockfile exists
+    await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
+    // "Touch" the file to ensure it exists before locking
+    await fs.appendFile(lockfilePath, "").catch(() => { });
+    try {
+        release = await lock(lockfilePath, { retries: 0 });
+    }
+    catch (e) {
+        if (e.code === "ELOCKED") {
+            console.error(`❌ Another rwsync process is already watching ${targetDir}.`);
+            console.error(`   If this is not correct, please remove the lockfile at ${lockfilePath}`);
+            process.exit(1);
+        }
+        throw e;
+    }
+    // Initial sync for watch mode. We do it *after* acquiring the lock.
+    let initialSyncOk = false;
+    try {
+        await performSync(sdkDir, targetDir);
+        initialSyncOk = true;
+    }
+    catch (error) {
+        console.error("❌ Initial sync failed:", error);
+        console.log("   Still watching for changes...");
+    }
+    const filesToWatch = [
+        path.join(sdkDir, "src"),
+        path.join(sdkDir, "types"),
+        path.join(sdkDir, "bin"),
+        path.join(sdkDir, "package.json"),
+    ];
+    console.log("👀 Watching for changes...");
+    let childProc = null;
+    const runWatchedCommand = () => {
+        if (typeof watch === "string") {
+            console.log(`\n> ${watch}\n`);
+            childProc = $({
+                stdio: "inherit",
+                shell: true,
+                cwd: targetDir,
+                reject: false,
+            }) `${watch}`;
+        }
+    };
+    const watcher = chokidar.watch(filesToWatch, {
+        ignoreInitial: true,
+        cwd: sdkDir,
+    });
+    watcher.on("all", async () => {
+        console.log("\nDetected change, re-syncing...");
+        if (childProc && !childProc.killed) {
+            console.log("Stopping running process...");
+            childProc.kill();
+            await childProc.catch(() => {
+                /* ignore kill errors */
+            });
+        }
+        try {
+            await performSync(sdkDir, targetDir);
+            runWatchedCommand();
+        }
+        catch (error) {
+            console.error("❌ Sync failed:", error);
+            console.log("   Still watching for changes...");
+        }
+    });
+    const cleanup = async () => {
+        console.log("\nCleaning up...");
+        if (childProc && !childProc.killed) {
+            childProc.kill();
+        }
+        await release();
+        process.exit();
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    if (initialSyncOk) {
+        runWatchedCommand();
+    }
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    const args = process.argv.slice(2);
+    const watchFlagIndex = args.indexOf("--watch");
+    let watchCmd = watchFlagIndex !== -1;
+    let cmdArgs = args;
+    if (watchFlagIndex !== -1) {
+        if (watchFlagIndex + 1 < args.length &&
+            !args[watchFlagIndex + 1].startsWith("--")) {
+            watchCmd = args[watchFlagIndex + 1];
+        }
+        // remove --watch and its potential command from args
+        const watchArgCount = typeof watchCmd === "string" ? 2 : 1;
+        cmdArgs = args.filter((_, i) => i < watchFlagIndex || i >= watchFlagIndex + watchArgCount);
+    }
+    const targetDir = cmdArgs[0] ?? process.cwd();
+    const sdkDir = path.resolve(__dirname, "..", "..");
+    debugSync({
+        targetDir,
+        sdkDir,
+        watch: watchCmd,
+    });
+}

package/dist/scripts/dev-init.d.mts

@@ -0,0 +1 @@
+export declare const initDev: () => Promise<never>;

package/dist/scripts/dev-init.mjs

@@ -0,0 +1,25 @@
+import { $ } from "../lib/$.mjs";
+import { hasPkgScript } from "../lib/hasPkgScript.mjs";
+export const initDev = async () => {
+    console.log("Initializing development environment...");
+    const projectRootDir = process.cwd();
+    if (await hasPkgScript(projectRootDir, "generate")) {
+        console.log("Generating...");
+        await $ `npm run generate`;
+    }
+    if (await hasPkgScript(projectRootDir, "migrate:dev")) {
+        console.log("Running migrations...");
+        await $ `npm run migrate:dev`;
+    }
+    if (await hasPkgScript(projectRootDir, "seed")) {
+        console.log("Seeding database...");
+        await $ `npm run seed`;
+    }
+    console.log("Done!");
+    console.log();
+    // todo(justinvdm, 01 Apr 2025): Investigate what handles are remaining open
+    process.exit(0);
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    initDev();
+}

package/dist/scripts/ensure-deploy-env.d.mts

@@ -0,0 +1 @@
+export declare const ensureDeployEnv: () => Promise<never>;

package/dist/scripts/ensure-deploy-env.mjs

@@ -0,0 +1,271 @@
+import { $ } from "../lib/$.mjs";
+import { readFile, writeFile } from "fs/promises";
+import { resolve, basename, join } from "path";
+import { randomBytes } from "crypto";
+import { glob } from "glob";
+import { parse as parseJsonc } from "jsonc-parser";
+import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
+import * as readline from "readline";
+import { pathExists } from "fs-extra";
+import { parseJson, extractAllJson } from "../lib/jsonUtils.mjs";
+const promptForDeployment = async () => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        // Handle Ctrl+C (SIGINT)
+        rl.on('SIGINT', () => {
+            rl.close();
+            console.log('\nDeployment cancelled.');
+            process.exit(1);
+        });
+        rl.question("Do you want to proceed with deployment? (y/N): ", (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+};
+const generateSecretKey = () => {
+    return randomBytes(32).toString("base64");
+};
+const hasWebAuthn = async () => {
+    const files = await glob("src/**/*.{ts,tsx}", { ignore: "node_modules/**" });
+    for (const file of files) {
+        const content = await readFile(file, "utf-8");
+        if (content.includes("WEBAUTHN")) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasD1Database = async () => {
+    const files = await glob("src/**/*.{ts,tsx}", { ignore: "node_modules/**" });
+    for (const file of files) {
+        const content = await readFile(file, "utf-8");
+        if (content.includes("env.DB")) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasAuthUsage = async () => {
+    const files = await glob("src/**/*.{ts,tsx}", { ignore: "node_modules/**" });
+    for (const file of files) {
+        const content = await readFile(file, "utf-8");
+        if (content.includes("rwsdk/auth")) {
+            return true;
+        }
+    }
+    return false;
+};
+export const ensureDeployEnv = async () => {
+    const shouldDeploy = await promptForDeployment();
+    if (!shouldDeploy) {
+        console.log("Deployment cancelled.");
+        process.exit(1);
+    }
+    console.log("Ensuring deployment environment is ready...");
+    const pkg = JSON.parse(await readFile(resolve(process.cwd(), "package.json"), "utf-8"));
+    // Read wrangler config
+    const wranglerPath = resolve(process.cwd(), "wrangler.jsonc");
+    const wranglerConfig = parseJsonc(await readFile(wranglerPath, "utf-8"));
+    // Update wrangler name if needed
+    if (wranglerConfig.name === "__change_me__" ||
+        process.env.RWSDK_RENAME_WORKER === "1") {
+        const dirName = basename(process.cwd());
+        wranglerConfig.name = dirName;
+        console.log(`Set wrangler name to ${dirName}`);
+        await writeFile(wranglerPath, JSON.stringify(wranglerConfig, null, 2));
+        console.log("Updated wrangler.jsonc configuration");
+    }
+    if (process.env.CLOUDFLARE_ACCOUNT_ID == null ||
+        process.env.CLOUDFLARE_API_TOKEN == null) {
+        // Trigger account selection prompt if needed
+        console.log("Checking Cloudflare account setup...");
+        const accountCachePath = join(process.cwd(), "node_modules/.cache/wrangler/wrangler-account.json");
+        // todo(justinvdm): this is a hack to force the account selection prompt,
+        // we need to find a better way
+        if (!(await pathExists(accountCachePath))) {
+            await $({ stdio: "inherit" }) `npx wrangler d1 list --json`;
+        }
+    }
+    // Create a no-op secret to ensure worker exists
+    console.log(`Ensuring worker ${wranglerConfig.name} exists...`);
+    await $({ stdio: "pipe" }) `echo "true"`
+        .pipe `npx wrangler secret put TMP_WORKER_CREATED`;
+    // Check D1 database setup
+    const needsDatabase = await hasD1Database();
+    if (!needsDatabase) {
+        console.log("Skipping D1 setup - no env.DB usage detected in codebase");
+    }
+    else {
+        console.log("Found env.DB usage, checking D1 database setup...");
+        try {
+            const existingDb = wranglerConfig.d1_databases?.find((db) => db.binding === "DB");
+            if (existingDb &&
+                existingDb.database_id !== "__change_me__" &&
+                process.env.RWSDK_RENAME_DB !== "1") {
+                console.log("D1 database already configured in wrangler.jsonc, skipping creation");
+            }
+            else {
+                const suffix = uniqueNamesGenerator({
+                    dictionaries: [adjectives, animals],
+                    separator: "-",
+                    length: 2,
+                    style: "lowerCase",
+                });
+                const dbName = `${wranglerConfig.name}-${suffix}`;
+                try {
+                    // Create the database with real-time output so the user can see progress
+                    console.log(`Creating D1 database: ${dbName}...`);
+                    const createResult = await $({
+                        stdio: "pipe",
+                    }) `npx wrangler d1 create ${dbName}`;
+                    // Log the result to the console
+                    console.log(createResult.stdout);
+                    // Parse all JSON objects from the output
+                    const allJsonObjects = extractAllJson(createResult.stdout);
+                    // First look for object with uuid directly
+                    let dbInfo = { uuid: undefined, name: undefined };
+                    for (const obj of allJsonObjects) {
+                        if (obj && obj.uuid) {
+                            dbInfo = obj;
+                            break;
+                        }
+                    }
+                    // If not found, look for the d1_databases structure
+                    if (!dbInfo.uuid) {
+                        for (const obj of allJsonObjects) {
+                            if (obj && obj.d1_databases && Array.isArray(obj.d1_databases)) {
+                                const dbConfig = obj.d1_databases.find((db) => db.binding === "DB" || db.database_name === dbName);
+                                if (dbConfig && dbConfig.database_id) {
+                                    dbInfo.uuid = dbConfig.database_id;
+                                    dbInfo.name = dbConfig.database_name || dbName;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!dbInfo.uuid) {
+                        throw new Error("Failed to extract database ID from wrangler output");
+                    }
+                    // Update wrangler config with database info, preserving other databases
+                    const existingDatabases = wranglerConfig.d1_databases || [];
+                    wranglerConfig.d1_databases = [
+                        ...existingDatabases.filter((db) => db.binding !== "DB"),
+                        {
+                            binding: "DB",
+                            database_name: dbName,
+                            database_id: dbInfo.uuid,
+                        },
+                    ];
+                    await writeFile(wranglerPath, JSON.stringify(wranglerConfig, null, 2));
+                    console.log("Updated wrangler.jsonc configuration");
+                    console.log(`D1 database configured: ${dbName} with ID: ${dbInfo.uuid}`);
+                }
+                catch (error) {
+                    console.error("Failed to create D1 database:", error instanceof Error ? error.message : String(error));
+                    console.error("Please create it manually:");
+                    console.error("1. Run: npx wrangler d1 create <your-db-name>");
+                    console.error("2. Update wrangler.jsonc with the database details");
+                    process.exit(1);
+                }
+            }
+        }
+        catch (error) {
+            console.error("Failed to create D1 database. Please create it manually:");
+            console.error("1. Run: npx wrangler d1 create <your-db-name>");
+            console.error("2. Update wrangler.jsonc with the database details");
+            process.exit(1);
+        }
+    }
+    // Check AUTH_SECRET_KEY setup
+    if (!(await hasAuthUsage())) {
+        console.log("Skipping AUTH_SECRET_KEY setup - no auth usage detected in codebase");
+    }
+    else {
+        console.log("Found auth usage, checking secret setup...");
+        try {
+            // Get list of all secrets
+            const secretsResult = await $ `npx wrangler secret list --format=json`;
+            const existingSecrets = parseJson(secretsResult.stdout, []).map((secret) => secret.name);
+            // Check if AUTH_SECRET_KEY already exists
+            if (existingSecrets.includes("AUTH_SECRET_KEY")) {
+                console.log("AUTH_SECRET_KEY secret already exists in Cloudflare, skipping");
+            }
+            else {
+                // Secret doesn't exist, create it
+                const secretKey = generateSecretKey();
+                // Use the same pattern as TMP_WORKER_CREATED for consistency
+                await $({ stdio: "pipe" }) `echo "${secretKey}"`
+                    .pipe `npx wrangler secret put AUTH_SECRET_KEY`;
+                console.log("Set AUTH_SECRET_KEY secret");
+            }
+        }
+        catch (error) {
+            console.error("Failed to set up AUTH_SECRET_KEY. Please configure it manually:");
+            console.error("1. Generate a secret key: node -e \"console.log(require('crypto').randomBytes(32).toString('base64'))\"");
+            console.error("2. Set the secret: npx wrangler secret put AUTH_SECRET_KEY");
+            process.exit(1);
+        }
+    }
+    // Check WebAuthn setup
+    const needsWebAuthn = await hasWebAuthn();
+    if (!needsWebAuthn) {
+        console.log("Skipping WebAuthn setup - no WEBAUTHN usage detected in codebase");
+    }
+    else {
+        console.log("Found WEBAUTHN usage, checking WebAuthn setup...");
+        try {
+            wranglerConfig.vars = wranglerConfig.vars || {};
+            if (wranglerConfig.vars.WEBAUTHN_APP_NAME === wranglerConfig.name) {
+                console.log(`WEBAUTHN_APP_NAME already set to "${wranglerConfig.name}" in wrangler.jsonc`);
+            }
+            else {
+                wranglerConfig.vars.WEBAUTHN_APP_NAME = wranglerConfig.name;
+                await writeFile(wranglerPath, JSON.stringify(wranglerConfig, null, 2));
+                console.log("Updated wrangler.jsonc configuration");
+                console.log(`Set WEBAUTHN_APP_NAME to ${wranglerConfig.name}`);
+            }
+        }
+        catch (error) {
+            console.error("Failed to set up WebAuthn. Please configure it manually:");
+            console.error("Add to wrangler.jsonc vars:");
+            console.error(`   "vars": { "WEBAUTHN_APP_NAME": "${wranglerConfig.name}" }`);
+            process.exit(1);
+        }
+    }
+    if (pkg.scripts?.["migrate:prd"]) {
+        console.log("Checking migration status...");
+        try {
+            // Get the database name from wrangler config
+            const dbConfig = wranglerConfig.d1_databases?.find((db) => db.binding === "DB");
+            if (!dbConfig) {
+                throw new Error("No D1 database configuration found in wrangler.jsonc");
+            }
+            // Check remote migrations status
+            const migrationStatus = await $ `npx wrangler d1 migrations list ${dbConfig.database_name} --remote`;
+            // If stdout includes "No migrations found", this is a fresh database
+            if (migrationStatus.stdout?.includes("No migrations present")) {
+                console.log("No migrations found.");
+            }
+            else if (migrationStatus.stdout?.includes("Migrations to be applied")) {
+                await $({ stdio: "inherit" }) `npm run migrate:prd`;
+            }
+            else {
+                console.log("Migrations are up to date.");
+            }
+        }
+        catch (error) {
+            console.error("\n❌ Error checking migration status:");
+            console.error(error);
+            process.exit(1);
+        }
+    }
+    console.log("\nDeployment initialization complete!");
+    process.exit(0);
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    ensureDeployEnv();
+}

package/dist/scripts/ensure-env.d.mts

@@ -0,0 +1 @@
+export declare const ensureEnv: () => Promise<void>;

package/dist/scripts/ensure-env.mjs

@@ -0,0 +1,9 @@
+import { setupEnvFiles } from "../lib/setupEnvFiles.mjs";
+export const ensureEnv = async () => {
+    await setupEnvFiles({
+        rootDir: process.cwd(),
+    });
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    ensureEnv();
+}

package/dist/scripts/migrate-new.d.mts

@@ -0,0 +1 @@
+export declare const migrateNew: (name: string, skipApply?: boolean) => Promise<void>;

package/dist/scripts/migrate-new.mjs

@@ -0,0 +1,51 @@
+import snakeCase from "lodash/snakeCase.js";
+import { $ } from "../lib/$.mjs";
+import { readdir } from "fs/promises";
+import { resolve } from "path";
+import { mkdirp } from "fs-extra";
+import { writeFile } from "fs/promises";
+const getNextMigrationNumber = async () => {
+    await mkdirp(resolve(process.cwd(), "./migrations"));
+    const files = await readdir(resolve(process.cwd(), "./migrations"));
+    const numbers = files
+        .map((file) => parseInt(file.split("_")[0]))
+        .filter((num) => !isNaN(num));
+    const lastNumber = Math.max(0, ...numbers);
+    return String(lastNumber + 1).padStart(4, "0");
+};
+export const migrateNew = async (name, skipApply = false) => {
+    if (!name) {
+        console.log("Usage: npm run migrate:new <migration-name> [--no-apply]");
+        console.log("Example: npm run migrate:new add a user");
+        process.exit(1);
+    }
+    const nextNum = await getNextMigrationNumber();
+    const filepath = `./migrations/${nextNum}_${snakeCase(name.toLowerCase())}.sql`;
+    const raw = await $ `npx prisma migrate diff --from-local-d1 --to-schema-datamodel ./prisma/schema.prisma --script`;
+    const cleaned = raw.stdout
+        ?.split("\n")
+        .filter((line) => !line.includes("_cf_METADATA") && !line.includes("_cf_metadata"))
+        .join("\n");
+    if (!cleaned) {
+        console.error("No changes to apply");
+        process.exitCode = 1;
+        return;
+    }
+    await writeFile(filepath, cleaned);
+    console.log("Generated migration:", filepath);
+    if (!skipApply) {
+        console.log("Applying migration in development...");
+        await $ `npm run migrate:dev`;
+        console.log("Generating Prisma Client");
+        await $ `npx prisma generate`;
+    }
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    const args = process.argv.slice(2);
+    // Separate flags from other arguments
+    const flags = new Set(args.filter((arg) => arg.startsWith("--")));
+    const nonFlags = args.filter((arg) => !arg.startsWith("--"));
+    const skipApply = flags.has("--no-apply");
+    const name = nonFlags.join("_").toLocaleLowerCase();
+    migrateNew(name, skipApply);
+}

package/dist/scripts/smoke-test.d.mts

@@ -0,0 +1 @@
+export {};