@reliverse/dler 1.7.145 → 1.7.147

package/bin/impl/monorepo/commands-mod.js

@@ -0,0 +1,159 @@
+import { relinka } from "@reliverse/relinka";
+import { execaCommand } from "execa";
+import { globby } from "globby";
+import {
+  cachePackageOutput,
+  cleanCache,
+  hashPackage,
+  isPackageCached,
+  restorePackageCache
+} from "./cache-mod.js";
+import { DependencyGraph } from "./graph-mod.js";
+import {
+  findMonorepo,
+  getCacheDir,
+  readPackageJson
+} from "./monorepo-mod.js";
+export async function buildCommand(ctx) {
+  if (process.env.INSIDE_DLER === "true") {
+    if (ctx.isDebug) {
+      relinka(
+        "log",
+        `[dler] \u2192 Ignoring dler, running command immediately: ${ctx.cmdArgs.join(" ")}`
+      );
+    }
+    if (ctx.cmdArgs.length === 0) {
+      relinka("error", "No command provided");
+      process.exit(1);
+    }
+    const command = ctx.cmdArgs.join(" ");
+    await execaCommand(command);
+    return;
+  }
+  const monorepo = await requireMonorepo(ctx);
+  const graph = await createGraph(monorepo);
+  const activePackage = requireActivePackage(ctx, graph);
+  const dependencies = graph.getPackageDependenciesBuildOrder(activePackage.name);
+  const packagesToBuild = [...dependencies, activePackage];
+  await buildCachedPackages(ctx, monorepo, packagesToBuild);
+}
+export async function depsCommand(ctx) {
+  if (process.env.INSIDE_DLER === "true") {
+    return;
+  }
+  const monorepo = await requireMonorepo(ctx);
+  const graph = await createGraph(monorepo);
+  const activePackage = requireActivePackage(ctx, graph);
+  const dependencies = graph.getPackageDependenciesBuildOrder(activePackage.name);
+  await buildCachedPackages(ctx, monorepo, dependencies);
+}
+export async function allCommand(ctx) {
+  const monorepo = await requireMonorepo(ctx);
+  const graph = await createGraph(monorepo);
+  const packages = graph.getOverallBuildOrder();
+  await buildCachedPackages(ctx, monorepo, packages);
+}
+export async function graphCommand(ctx) {
+  const monorepo = await requireMonorepo(ctx);
+  const graph = await createGraph(monorepo);
+  graph.print();
+}
+export async function cleanCommand(ctx) {
+  const monorepo = await findMonorepo();
+  if (monorepo) {
+    const cacheDir = getCacheDir(monorepo);
+    if (ctx.isDebug) {
+      relinka("log", `[dler] \u2192 Deleting cache at ${cacheDir}`);
+    }
+    await cleanCache(monorepo);
+  } else {
+    if (ctx.isDebug) {
+      relinka("log", "[dler] \u2192 Not in monorepo");
+    }
+  }
+  relinka("log", "\u2713 Cache deleted");
+}
+async function requireMonorepo(ctx) {
+  const monorepo = await findMonorepo();
+  if (!monorepo) {
+    relinka("error", "Monorepo root not found. Are you inside a monorepo?");
+    process.exit(1);
+  }
+  if (ctx.isDebug) {
+    relinka("log", `[dler] \u2192 Monorepo found at ${monorepo.root}`);
+  }
+  return monorepo;
+}
+async function createGraph(monorepo) {
+  const packageJsonGlobs = monorepo.packageGlobs.map((glob) => `${glob}/package.json`);
+  const matches = await globby(packageJsonGlobs, { cwd: monorepo.root, absolute: true });
+  const packages = [];
+  for (const packageJsonPath of matches) {
+    const pkg = await readPackageJson(packageJsonPath);
+    if (pkg) {
+      packages.push(pkg);
+    }
+  }
+  return new DependencyGraph(packages);
+}
+function requireActivePackage(ctx, graph) {
+  const activePackage = graph.findActivePackage();
+  if (!activePackage) {
+    relinka("error", "Not inside a package directory, could not determine dependencies to build");
+    process.exit(1);
+  }
+  if (ctx.isDebug) {
+    relinka("log", `[dler] \u2192 Active package ${activePackage.dir}`);
+  }
+  return activePackage;
+}
+async function buildCachedPackages(ctx, monorepo, packages) {
+  if (ctx.isDebug) {
+    const packageNames = packages.map((p) => p.name);
+    relinka("log", `[dler] \u2192 Packages to build: ${packageNames.join(", ")}`);
+  }
+  for (const pkg of packages) {
+    await buildCachedPackage(ctx, monorepo, pkg);
+  }
+}
+async function buildCachedPackage(ctx, monorepo, pkg) {
+  if (!pkg.buildScript) {
+    relinka("log", `\u2713 ${pkg.name}: Nothing to build`);
+    return;
+  }
+  const args = [...monorepo.packageManager.runCmd, "build"];
+  if (ctx.isDebug) {
+    const relativeDir = pkg.dir.replace(monorepo.root, "").replace(/^\//, "");
+    relinka("log", `[dler] \u2192 Running ${args.join(" ")} in ${relativeDir}`);
+  }
+  relinka("log", `\u25D0 ${pkg.name}: ${pkg.buildScript}`);
+  const { packageHash } = await hashPackage(pkg);
+  const cacheDir = getPackageCacheDir(monorepo, pkg, packageHash);
+  if (ctx.isDebug) {
+    relinka("log", `[dler] \u2192 Cache dir: ${cacheDir}`);
+  }
+  if (await isPackageCached(monorepo, pkg, packageHash) && pkg.config.cache) {
+    await restorePackageCache(monorepo, pkg, packageHash);
+    relinka("log", `\u2713 ${pkg.name}: Cached!`);
+    return;
+  }
+  await execInDir(pkg.dir, args);
+  if (pkg.config.cache) {
+    await cachePackageOutput(monorepo, pkg, packageHash);
+  }
+  relinka("log", `\u2713 ${pkg.name}: Built`);
+}
+async function execInDir(dir, args) {
+  if (args.length === 0) {
+    relinka("error", "No command provided");
+    process.exit(1);
+  }
+  const command = args.join(" ");
+  await execaCommand(command, {
+    cwd: dir,
+    env: { ...process.env, INSIDE_DLER: "true" }
+  });
+}
+function getPackageCacheDir(monorepo, pkg, packageHash) {
+  return `${monorepo.root}/.cache/${pkg.name}/${packageHash}`;
+}

package/bin/impl/monorepo/graph-mod.d.ts

@@ -0,0 +1,29 @@
+import type { Package } from "./monorepo-mod";
+export interface GraphNode {
+    id: string;
+    package: Package;
+    children: GraphNode[];
+}
+export declare class DependencyGraph {
+    private readonly root;
+    private readonly nodeMap;
+    constructor(packages: Package[]);
+    /**
+     * Get all packages in build order (dependencies first)
+     */
+    getOverallBuildOrder(): Package[];
+    /**
+     * Get dependencies for a specific package in build order
+     */
+    getPackageDependenciesBuildOrder(packageName: string): Package[];
+    /**
+     * Find the package that contains the current working directory
+     */
+    findActivePackage(): Package | null;
+    /**
+     * Print the dependency graph as a tree
+     */
+    print(): void;
+    private depthFirstSearch;
+    private printNode;
+}

package/bin/impl/monorepo/graph-mod.js

@@ -0,0 +1,106 @@
+import { relinka } from "@reliverse/relinka";
+export class DependencyGraph {
+  root;
+  nodeMap = /* @__PURE__ */ new Map();
+  constructor(packages) {
+    this.root = {
+      id: "root",
+      package: {
+        dir: "",
+        name: "root",
+        dependencyNames: [],
+        config: { cache: false, outDir: "dist", include: [], exclude: [] }
+      },
+      children: []
+    };
+    const nodes = packages.map((pkg) => ({
+      id: pkg.name,
+      package: pkg,
+      children: []
+    }));
+    this.root.children = [...nodes];
+    for (const node of nodes) {
+      this.nodeMap.set(node.id, node);
+    }
+    for (const pkg of packages) {
+      const packageNode = this.nodeMap.get(pkg.name);
+      if (!packageNode) continue;
+      for (const depName of pkg.dependencyNames) {
+        const depNode = this.nodeMap.get(depName);
+        if (depNode) {
+          packageNode.children.push(depNode);
+        }
+      }
+    }
+  }
+  /**
+   * Get all packages in build order (dependencies first)
+   */
+  getOverallBuildOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const child of this.root.children) {
+      this.depthFirstSearch(child, visited, result);
+    }
+    return result;
+  }
+  /**
+   * Get dependencies for a specific package in build order
+   */
+  getPackageDependenciesBuildOrder(packageName) {
+    const node = this.nodeMap.get(packageName);
+    if (!node) return [];
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const child of node.children) {
+      this.depthFirstSearch(child, visited, result);
+    }
+    return result;
+  }
+  /**
+   * Find the package that contains the current working directory
+   */
+  findActivePackage() {
+    const currentDir = process.cwd();
+    for (const node of this.root.children) {
+      if (currentDir.startsWith(node.package.dir)) {
+        return node.package;
+      }
+    }
+    return null;
+  }
+  /**
+   * Print the dependency graph as a tree
+   */
+  print() {
+    relinka("log", "Dependency Graph:");
+    this.printNode(this.root, 0, true);
+  }
+  depthFirstSearch(node, visited, result) {
+    if (visited.has(node.id)) return;
+    visited.add(node.id);
+    for (const child of node.children) {
+      this.depthFirstSearch(child, visited, result);
+    }
+    if (node.id !== "root") {
+      result.push(node.package);
+    }
+  }
+  printNode(node, depth, isLast) {
+    const indent = "\u2502 ".repeat(depth);
+    const connector = isLast ? "\u2514" : "\u251C";
+    const name = node.id === "root" ? "" : node.id;
+    if (name) {
+      relinka("log", `${indent}${connector} ${name}`);
+    }
+    if (node.children.length > 0) {
+      const lastIndex = node.children.length - 1;
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        if (child) {
+          this.printNode(child, depth + 1, i === lastIndex);
+        }
+      }
+    }
+  }
+}

package/bin/impl/monorepo/mod.d.ts

@@ -0,0 +1,5 @@
+export * from "./cache-mod";
+export * from "./commands-mod";
+export * from "./graph-mod";
+export * from "./monorepo-mod";
+export { readPackageJson as readMonorepoPackageJson } from "./monorepo-mod";

package/bin/impl/monorepo/mod.js

@@ -0,0 +1,5 @@
+export * from "./cache-mod.js";
+export * from "./commands-mod.js";
+export * from "./graph-mod.js";
+export * from "./monorepo-mod.js";
+export { readPackageJson as readMonorepoPackageJson } from "./monorepo-mod.js";

package/bin/impl/monorepo/monorepo-mod.d.ts

@@ -0,0 +1,26 @@
+export interface PackageManager {
+    name: "pnpm" | "bun" | "npm" | "yarn";
+    runCmd: string[];
+}
+export interface Package {
+    dir: string;
+    name: string;
+    buildScript?: string;
+    dependencyNames: string[];
+    config: PackageConfig;
+}
+export interface PackageConfig {
+    cache: boolean;
+    outDir: string;
+    include: string[];
+    exclude: string[];
+}
+export interface Monorepo {
+    root: string;
+    packageManager: PackageManager;
+    packageGlobs: string[];
+}
+export declare function createPackageConfig(json: any): PackageConfig;
+export declare function findMonorepo(): Promise<Monorepo | null>;
+export declare function readPackageJson(packageJsonPath: string): Promise<Package | null>;
+export declare function getCacheDir(monorepo: Monorepo): string;

package/bin/impl/monorepo/monorepo-mod.js

@@ -0,0 +1,152 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
+const DEFAULT_CACHED = true;
+const DEFAULT_OUT_DIR = "dist";
+const DEFAULT_INCLUDE = ["src/**/*"];
+const DEFAULT_EXCLUDE = [
+  "**/__tests__/**",
+  "**/__mocks__/**",
+  "**/*.test.*",
+  "**/e2e/**",
+  "**/dist/**",
+  "**/.output/**"
+];
+export function createPackageConfig(json) {
+  const dler = json.dler || {};
+  return {
+    cache: dler.cache ?? DEFAULT_CACHED,
+    outDir: dler.outDir ?? DEFAULT_OUT_DIR,
+    include: dler.include ?? DEFAULT_INCLUDE,
+    exclude: dler.exclude ?? DEFAULT_EXCLUDE
+  };
+}
+export async function findMonorepo() {
+  let currentDir = process.cwd();
+  while (true) {
+    const workspace = await readWorkspace(currentDir);
+    if (workspace) {
+      return {
+        root: currentDir,
+        packageManager: workspace.packageManager,
+        packageGlobs: workspace.packageGlobs
+      };
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function readWorkspace(path2) {
+  const pnpmWorkspacePath = path2 + "/pnpm-workspace.yaml";
+  if (await fs.pathExists(pnpmWorkspacePath)) {
+    try {
+      const content = await fs.readFile(pnpmWorkspacePath, "utf-8");
+      const yaml = JSON.parse(content);
+      const packages = yaml.packages || [];
+      return {
+        packageManager: {
+          name: "pnpm",
+          runCmd: ["pnpm", "--silent", "run"]
+        },
+        packageGlobs: packages
+      };
+    } catch (error) {
+      relinka("warn", `Failed to parse pnpm-workspace.yaml: ${error}`);
+    }
+  }
+  const packageJsonPath = path2 + "/package.json";
+  if (await fs.pathExists(packageJsonPath)) {
+    try {
+      const content = await fs.readFile(packageJsonPath, "utf-8");
+      const json = JSON.parse(content);
+      if (json.workspaces) {
+        const detectedPM = await detectPackageManager(path2, {
+          ignorePackageJSON: true
+          // We already have the package.json
+        });
+        let packageManager;
+        if (detectedPM) {
+          switch (detectedPM.name) {
+            case "bun":
+              packageManager = {
+                name: "bun",
+                runCmd: ["bun", "--silent", "run"]
+              };
+              break;
+            case "yarn":
+              packageManager = {
+                name: "yarn",
+                runCmd: ["yarn", "run"]
+              };
+              break;
+            case "npm":
+              packageManager = {
+                name: "npm",
+                runCmd: ["npm", "run"]
+              };
+              break;
+            case "pnpm":
+              packageManager = {
+                name: "pnpm",
+                runCmd: ["pnpm", "--silent", "run"]
+              };
+              break;
+            default:
+              packageManager = {
+                name: "bun",
+                runCmd: ["bun", "--silent", "run"]
+              };
+          }
+        } else {
+          packageManager = {
+            name: "bun",
+            runCmd: ["bun", "--silent", "run"]
+          };
+        }
+        return {
+          packageManager,
+          packageGlobs: Array.isArray(json.workspaces) ? json.workspaces : []
+        };
+      }
+    } catch (error) {
+      relinka("warn", `Failed to parse package.json: ${error}`);
+    }
+  }
+  return null;
+}
+export async function readPackageJson(packageJsonPath) {
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    const json = JSON.parse(content);
+    const name = json.name;
+    if (!name) {
+      return null;
+    }
+    const buildScript = json.scripts?.build;
+    const dependencyNames = [];
+    const deps = { ...json.dependencies, ...json.devDependencies };
+    for (const [depName, version] of Object.entries(deps)) {
+      if (typeof version === "string" && version.startsWith("workspace:")) {
+        dependencyNames.push(depName);
+      }
+    }
+    return {
+      dir: path.dirname(packageJsonPath),
+      name,
+      buildScript,
+      dependencyNames,
+      config: createPackageConfig(json)
+    };
+  } catch (error) {
+    relinka("warn", `Failed to read package.json at ${packageJsonPath}: ${error}`);
+    return null;
+  }
+}
+export function getCacheDir(monorepo) {
+  return path.join(monorepo.root, ".cache");
+}

package/bin/impl/providers/better-t-stack/packed/addons.js

@@ -146,7 +146,7 @@ export const DLER_TPL_ADDONS = {
         type: "binary",
         binaryHash: "dee83fc2fb"
       },
-      "addons/pwa/apps/web/next/src-ts/impl/manifest.ts.hbs": {
+      "addons/pwa/apps/web/next/src/impl/manifest.ts.hbs": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "6f8734ebe6"

package/bin/impl/providers/better-t-stack/packed/api.js

@@ -188,7 +188,7 @@ export const protectedProcedure = publicProcedure.use(requireAuth);
 `,
         type: "text"
       },
-      "api/orpc/server/next/src-ts/impl/rpc/[...all]/route.ts.hbs": {
+      "api/orpc/server/next/src/impl/rpc/[...all]/route.ts.hbs": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "cdf4279672"
@@ -556,7 +556,7 @@ export const protectedProcedure = t.procedure.use(({ ctx, next }) => {
 `,
         type: "text"
       },
-      "api/trpc/server/next/src-ts/impl/trpc/[trpc]/route.ts": {
+      "api/trpc/server/next/src/impl/trpc/[trpc]/route.ts": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "1316017eae"

package/bin/impl/providers/better-t-stack/packed/auth.js

@@ -1403,7 +1403,7 @@ model Verification {
 `,
         type: "text"
       },
-      "auth/server/next/src-ts/impl/api/auth/[...all]/route.ts": {
+      "auth/server/next/src/impl/api/auth/[...all]/route.ts": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "1eeae5d0e3"
@@ -1727,7 +1727,7 @@ export const authClient = createAuthClient({
 `,
         type: "text"
       },
-      "auth/web/react/next/src-ts/impl/dashboard/page.tsx.hbs": {
+      "auth/web/react/next/src/impl/dashboard/page.tsx.hbs": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "354fab95c7"
@@ -1777,7 +1777,7 @@ export default function Dashboard() {
 `,
         type: "text"
       },
-      "auth/web/react/next/src-ts/impl/login/page.tsx": {
+      "auth/web/react/next/src/impl/login/page.tsx": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "bdd103cc10"

package/bin/impl/providers/better-t-stack/packed/backend.js

@@ -720,7 +720,7 @@ export default nextConfig;
 `,
         type: "text"
       },
-      "backend/server/next/src-ts/impl/route.ts": {
+      "backend/server/next/src/impl/route.ts": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "e40f5d7501"

package/bin/impl/providers/better-t-stack/packed/examples.js

@@ -486,7 +486,7 @@ export {};
 `,
         type: "text"
       },
-      "examples/ai/server/next/src-ts/impl/ai/route.ts": {
+      "examples/ai/server/next/src/impl/ai/route.ts": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "eee0d6a73d"
@@ -569,7 +569,7 @@ function getMessageText(message: any) {
 `,
         type: "text"
       },
-      "examples/ai/web/react/next/src-ts/impl/ai/page.tsx": {
+      "examples/ai/web/react/next/src/impl/ai/page.tsx": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "0c366c76eb"
@@ -2058,7 +2058,7 @@ function handleDeleteTodo(id: number) {
 `,
         type: "text"
       },
-      "examples/todo/web/react/next/src-ts/impl/todos/page.tsx.hbs": {
+      "examples/todo/web/react/next/src/impl/todos/page.tsx.hbs": {
         metadata: {
           updatedAt: "2025-06-17T06:06:35.000Z",
           updatedHash: "dbf393c2f2"

package/bin/impl/providers/better-t-stack/types.d.ts

@@ -1,22 +1,22 @@
 import { z } from "zod";
 export declare const DatabaseSchema: z.ZodEnum<{
-    mysql: "mysql";
+    none: "none";
     sqlite: "sqlite";
+    mysql: "mysql";
     mongodb: "mongodb";
-    none: "none";
     postgres: "postgres";
 }>;
 export type Database = z.infer<typeof DatabaseSchema>;
 export declare const ORMSchema: z.ZodEnum<{
-    mongoose: "mongoose";
     none: "none";
     drizzle: "drizzle";
     prisma: "prisma";
+    mongoose: "mongoose";
 }>;
 export type ORM = z.infer<typeof ORMSchema>;
 export declare const BackendSchema: z.ZodEnum<{
-    hono: "hono";
     none: "none";
+    hono: "hono";
     next: "next";
     convex: "convex";
     express: "express";
@@ -32,10 +32,10 @@ export declare const RuntimeSchema: z.ZodEnum<{
 }>;
 export type Runtime = z.infer<typeof RuntimeSchema>;
 export declare const FrontendSchema: z.ZodEnum<{
+    none: "none";
     svelte: "svelte";
     nuxt: "nuxt";
     solid: "solid";
-    none: "none";
     next: "next";
     "react-router": "react-router";
     "tanstack-router": "tanstack-router";
@@ -45,10 +45,10 @@ export declare const FrontendSchema: z.ZodEnum<{
 }>;
 export type Frontend = z.infer<typeof FrontendSchema>;
 export declare const AddonsSchema: z.ZodEnum<{
-    tauri: "tauri";
+    none: "none";
     biome: "biome";
+    tauri: "tauri";
     starlight: "starlight";
-    none: "none";
     turborepo: "turborepo";
     husky: "husky";
     pwa: "pwa";
@@ -56,14 +56,14 @@ export declare const AddonsSchema: z.ZodEnum<{
 export type Addons = z.infer<typeof AddonsSchema>;
 export declare const ExamplesSchema: z.ZodEnum<{
     none: "none";
-    todo: "todo";
     ai: "ai";
+    todo: "todo";
 }>;
 export type Examples = z.infer<typeof ExamplesSchema>;
 export declare const PackageManagerSchema: z.ZodEnum<{
+    bun: "bun";
     npm: "npm";
     pnpm: "pnpm";
-    bun: "bun";
 }>;
 export type PackageManager = z.infer<typeof PackageManagerSchema>;
 export declare const DatabaseSetupSchema: z.ZodEnum<{

package/bin/impl/pub/impl.d.ts

@@ -3,6 +3,6 @@ import type { PerfTimer } from "../types/mod.js";
 /**
  * Main entry point for the rse build and publish process.
  * Handles building and publishing for both main project and libraries.
- * @see `src-ts/impl/build/impl.ts` for build main function implementation.
+ * @see `src/impl/build/impl.ts` for build main function implementation.
  */
 export declare function dlerPub(timer: PerfTimer, isDev: boolean, config?: ReliverseConfig): Promise<void>;