@effect-app/cli 1.23.1 → 1.23.3

package/dist/old.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=old.d.ts.map

package/dist/old.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"old.d.ts","sourceRoot":"","sources":["../src/old.ts"],"names":[],"mappings":""}

package/dist/old.js

@@ -0,0 +1,246 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import cp from "child_process";
+import fs from "fs";
+import w from "node-watch";
+import path from "path";
+import readline from "readline/promises";
+import { sync } from "./sync.js";
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return rl.question(query);
+}
+const _cmd = process.argv[2];
+const supportedCommands = [
+    "watch",
+    "index",
+    "index-multi",
+    "packagejson",
+    "packagejson-target",
+    "packagejson-packages",
+    "link",
+    "unlink",
+    "sync",
+    "ncu:effect",
+    "ncu:effect-app"
+];
+if (!supportedCommands.includes(_cmd)) {
+    console.log("unknown command: ", _cmd, "supported commands: ", supportedCommands.join(", "));
+    process.exit(1);
+}
+const cmd = _cmd;
+const debug = process.argv.includes("--debug");
+function touch(path) {
+    const time = new Date();
+    try {
+        fs.utimesSync(path, time, time);
+    }
+    catch (err) {
+        fs.closeSync(fs.openSync(path, "w"));
+    }
+}
+function* monitorIndexes_(path) {
+    yield monitorChildIndexes(path);
+    const indexFile = path + "/index.ts";
+    if (fs.existsSync(indexFile)) {
+        yield monitorRootIndexes(path, indexFile);
+    }
+}
+function monitorIndexes(path) {
+    return [...monitorIndexes_(path)];
+}
+function monitorChildIndexes(path) {
+    return w.default(path, { recursive: true }, (evt, path) => {
+        const pathParts = path.split("/");
+        const isController = pathParts[pathParts.length - 1]?.toLowerCase().includes(".controllers.");
+        if (!isController)
+            return;
+        let i = 1;
+        const r = pathParts.toReversed();
+        while (i < r.length) {
+            const files = ["controllers.ts", "routes.ts"]
+                .map((f) => [...pathParts.slice(0, pathParts.length - i), f].join("/"))
+                .filter((f) => fs.existsSync(f));
+            if (files.length) {
+                if (debug) {
+                    console.log("change!", evt, path, files);
+                }
+                cp.execSync(`cd api && pnpm eslint --fix ${files.map((_) => `"../${_}"`).join(" ")}`);
+                break;
+            }
+            i++;
+        }
+    });
+}
+function monitorRootIndexes(path, indexFile) {
+    return w.default(path, (_, path) => {
+        if (path.endsWith(indexFile))
+            return;
+        // const dirName = pathParts[pathParts.length - 2]!
+        // console.log("change!", evt, path, dirName, indexFile)
+        cp.execSync(`pnpm eslint --fix "${indexFile}"`);
+    });
+}
+// TODO: cache, don't do things when it already existed before, so only file is updated, not created.
+const startDir = process.cwd();
+function packagejson(p, levels = 0) {
+    const curDir = process.cwd();
+    let r = "";
+    // TODO: no chdir!
+    try {
+        process.chdir(path.resolve(startDir, p));
+        r = cp.execSync(`sh ${p === "." ? "../.." : startDir}/scripts/extract.sh`, { encoding: "utf-8" });
+    }
+    finally {
+        process.chdir(curDir);
+    }
+    const s = r.split("\n").sort((a, b) => a < b ? -1 : 1).join("\n");
+    const items = JSON.parse(`{${s.substring(0, s.length - 1)} }`);
+    const pkg = JSON.parse(fs.readFileSync(p + "/package.json", "utf-8"));
+    const t = levels
+        ? Object
+            .keys(items)
+            .filter((_) => _.split("/").length <= (levels + 1 /* `./` */))
+            .reduce((prev, cur) => {
+            prev[cur] = items[cur];
+            return prev;
+        }, {})
+        : items;
+    const exps = {
+        ...(fs.existsSync(p + "/src/index.ts")
+            ? {
+                ".": {
+                    "types": "./dist/index.d.ts",
+                    "default": "./dist/index.js"
+                }
+            }
+            : undefined),
+        ...Object
+            .keys(t)
+            .reduce((prev, cur) => {
+            if (cur !== "./index" && !cur.includes("/internal/"))
+                prev[cur] = t[cur];
+            return prev;
+        }, {})
+        // ...pkg.name === "effect-app" ? {
+        //   "./types/awesome": { "types": "./types/awesome.d.ts" }
+        // } : {},
+    };
+    pkg.exports = exps;
+    fs.writeFileSync(p + "/package.json", JSON.stringify(pkg, null, 2));
+}
+function monitorPackagejson(path, levels = 0) {
+    packagejson(path, levels);
+    w.default(path + "/src", { recursive: true }, (_, __) => {
+        packagejson(path, levels);
+    });
+}
+function updateEffectAppPackages() {
+    const filters = ["effect-app", "@effect-app/*"];
+    for (const filter of filters) {
+        cp.execSync(`pnpm exec ncu -u --filter "${filter}"`, { stdio: "inherit" });
+        cp.execSync(`pnpm -r exec ncu -u --filter "${filter}"`, { stdio: "inherit" });
+    }
+}
+function updateEffectPackages() {
+    const effectFilters = ["effect", "@effect/*", "@effect-atom/*"];
+    for (const filter of effectFilters) {
+        cp.execSync(`pnpm exec ncu -u --filter "${filter}"`, { stdio: "inherit" });
+        cp.execSync(`pnpm -r exec ncu -u --filter "${filter}"`, { stdio: "inherit" });
+    }
+    updateEffectAppPackages();
+}
+;
+(async () => {
+    let cmds = process.argv.slice(3).filter((_) => _ !== "--debug");
+    switch (cmd) {
+        case "link":
+            await import("./link.js");
+            break;
+        case "unlink":
+            await import("./unlink.js");
+            break;
+        case "watch": {
+            const dirs = ["../api/src/resources", "../api/src/models"];
+            const viteConfigFile = "./vite.config.ts";
+            const viteConfigExists = fs.existsSync(viteConfigFile);
+            dirs.forEach((d) => {
+                if (fs.existsSync(d)) {
+                    const files = [];
+                    w.default(d, { recursive: true }, (t, f) => {
+                        // console.log("change!", d)
+                        touch("./tsconfig.json");
+                        if (viteConfigExists && t === "update" && !files.includes(f)) {
+                            // TODO: only on new files
+                            touch(viteConfigFile);
+                            files.push(f);
+                        }
+                    });
+                }
+            });
+            break;
+        }
+        case "index-multi": {
+            ;
+            [
+                "./api/src"
+            ]
+                .filter((_) => fs.existsSync(_))
+                .forEach(monitorIndexes);
+            break;
+        }
+        case "index": {
+            monitorIndexes("./src");
+            break;
+        }
+        case "packagejson": {
+            monitorPackagejson(".");
+            break;
+        }
+        case "packagejson-target": {
+            const target = process.argv[3];
+            target.split(",").forEach((_) => monitorPackagejson(_, 1));
+            cmds = process.argv.slice(4);
+            break;
+        }
+        case "packagejson-packages": {
+            fs
+                .readdirSync(startDir + "/packages")
+                .map((_) => startDir + "/packages/" + _)
+                .filter((_) => fs.existsSync(_ + "/package.json")
+                && fs.existsSync(_ + "/src")
+                && !_.endsWith("eslint-codegen-model")
+                && !_.endsWith("vue-components"))
+                .forEach((_) => monitorPackagejson(_));
+            break;
+        }
+        case "sync": {
+            console.log("Sync all snippets?");
+            await askQuestion("Are you sure you want to sync snippets");
+            await sync();
+            return process.exit(0);
+        }
+        case "ncu:effect": {
+            console.log("Updating effect & effect-app dependencies...");
+            updateEffectPackages();
+            cp.execSync("pnpm i", { stdio: "inherit" });
+            break;
+        }
+        case "ncu:effect-app": {
+            console.log("Updating effect-app dependencies...");
+            updateEffectAppPackages();
+            cp.execSync("pnpm i", { stdio: "inherit" });
+            break;
+        }
+    }
+    if (cmds.length) {
+        const p = cp.spawn(cmds[0], cmds.slice(1), { stdio: "inherit" });
+        p.on("close", (code) => process.exit(code ?? 0));
+        p.on("exit", (code) => process.exit(code ?? 0));
+        p.on("disconnect", () => process.exit(1));
+    }
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"old.js","sourceRoot":"","sources":["../src/old.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/cli",
-  "version": "1.23.1",
+  "version": "1.23.3",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -9,6 +9,8 @@
     "effect-app-cli": "./bin.js"
   },
   "dependencies": {
+    "@effect/cli": "^0.69.2",
+    "@effect/platform-node": "^0.94.1",
     "node-watch": "^0.7.4"
   },
   "devDependencies": {
@@ -29,10 +31,18 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./extract": {
+      "types": "./dist/extract.d.ts",
+      "default": "./dist/extract.js"
+    },
     "./link": {
       "types": "./dist/link.d.ts",
       "default": "./dist/link.js"
     },
+    "./old": {
+      "types": "./dist/old.d.ts",
+      "default": "./dist/old.js"
+    },
     "./shared": {
       "types": "./dist/shared.d.ts",
       "default": "./dist/shared.js"

package/src/extract.ts

@@ -0,0 +1,71 @@
+import { type Error as PlatformError, FileSystem, Path } from "@effect/platform"
+import { Array as EffectArray, Effect, Order, pipe } from "effect"
+
+/**
+ * Generates package.json exports mappings for TypeScript modules
+ * This function finds all .ts files in src/ (excluding test files) and generates
+ * JSON export entries that map source files to their compiled .js and .d.ts outputs
+ *
+ * Example output:
+ * "./utils/helper": { "types": "./dist/utils/helper.d.ts", "default": "./dist/utils/helper.js" },
+ *
+ * This allows users to import individual modules instead of the entire package:
+ * import { helper } from 'package/utils/helper' instead of 'package'
+ */
+export const ExtractExportMappingsService = Effect.fn("effa-cli.extractExportMappings")(function*() {
+  const fs = yield* FileSystem.FileSystem
+  const path = yield* Path.Path
+
+  return Effect.fn("effa-cli.extractExportMappings.service")(function*(cwd: string) {
+    const findTsFiles = (dir: string): Effect.Effect<string[], PlatformError.PlatformError, never> =>
+      Effect.gen(function*() {
+        const entries = yield* fs.readDirectory(dir)
+
+        const results = yield* Effect.all(
+          entries.map((entry) =>
+            Effect.gen(function*() {
+              const fullPath = path.join(dir, entry)
+              const stat = yield* fs.stat(fullPath)
+
+              if (stat.type === "Directory") {
+                return yield* findTsFiles(fullPath)
+              } else if (entry.endsWith(".ts") && !entry.includes(".test.")) {
+                return [fullPath]
+              }
+              return []
+            })
+          )
+        )
+
+        return EffectArray.flatten(results)
+      })
+
+    const srcDir = path.join(cwd, "src")
+
+    // Check if src directory exists
+    const srcExists = yield* fs.exists(srcDir)
+    if (!srcExists) {
+      return ""
+    }
+
+    const tsFiles = yield* findTsFiles(srcDir)
+
+    const exportMappings = tsFiles.map((filePath) => {
+      // Get relative path from src directory (like bash script's cut -c 5-)
+      const relativePath = path.relative(srcDir, filePath)
+      const exportKey = `./${relativePath.replace(/\.ts$/, "")}`
+      const distPath = `./dist/${relativePath.replace(/\.ts$/, ".js")}`
+      const typesPath = `./dist/${relativePath.replace(/\.ts$/, ".d.ts")}`
+
+      return `"${exportKey}": { "types": "${typesPath}", "default": "${distPath}" }`
+    })
+
+    const sortedMappings = pipe(
+      exportMappings,
+      EffectArray.sort(Order.string),
+      EffectArray.join(",\n")
+    )
+
+    return sortedMappings
+  })
+})()