@docker-harpoon/monorepo 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @harpoon/monorepo
+ *
+ * Package-manager agnostic monorepo binding for Harpoon.
+ *
+ * Provides:
+ * - MonorepoBinding: Build-time transformations for monorepo structure
+ * - Build strategy for simulating monorepo structure
+ * - Dockerfile transformers for monorepo paths
+ *
+ * Note: This package does NOT assume any specific package manager.
+ * Users should configure their own root files (lock files, workspace configs).
+ */
+import type { BuildBinding } from '@harpoon/core';
+export { monorepoTransformers, monorepoRootFilesTransformer, monorepoCopyAllTransformer, monorepoDataPathTransformer, } from './transformers/monorepo';
+export { monorepoSimulationStrategy } from './strategies/monorepo-simulation';
+export interface MonorepoBindingOptions {
+    /** App name within the monorepo (e.g., "web", "api") */
+    appName: string;
+    /** Source directory for shared folders (default: context directory) */
+    source?: string;
+    /** Shared folders to copy (default: ['packages', 'tools']) */
+    sharedFolders?: readonly string[];
+    /** Root files to copy (default: ['package.json', 'pnpm-lock.yaml', 'pnpm-workspace.yaml', '.npmrc']) */
+    rootFiles?: readonly string[];
+}
+/**
+ * Creates a Monorepo binding for build-time transformations.
+ *
+ * This binding provides:
+ * - Build context preparation (simulating monorepo structure)
+ * - Dockerfile transformations for monorepo paths
+ * - Config patching for pnpm workspaces
+ *
+ * @example
+ * ```typescript
+ * import { Image } from '@harpoon/core';
+ * import { MonorepoBinding } from '@harpoon/monorepo';
+ * import { NextjsBinding } from '@harpoon/nextjs';
+ *
+ * const appImage = await Image("my-app:latest", {
+ *   context: "./apps/web",
+ *   bindings: {
+ *     MONOREPO: MonorepoBinding({
+ *       appName: "web",
+ *       source: "../..",  // monorepo root
+ *     }),
+ *     NEXTJS: NextjsBinding({ standalone: true }),
+ *   },
+ * });
+ * ```
+ */
+export declare function MonorepoBinding(options: MonorepoBindingOptions): BuildBinding<Record<string, never>>;
+/**
+ * Register all monorepo plugins with Harpoon's registries.
+ *
+ * Call this once at application startup if you want the strategy,
+ * patchers, and transformers to be available globally.
+ *
+ * @example
+ * ```typescript
+ * import { registerMonorepoPlugins } from '@harpoon/monorepo';
+ *
+ * registerMonorepoPlugins();
+ * ```
+ */
+export declare function registerMonorepoPlugins(): void;
+export default MonorepoBinding;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EACV,YAAY,EAOb,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAI9E,MAAM,WAAW,sBAAsB;IACrC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,wGAAwG;IACxG,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,GAC9B,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAoErC;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAgB9C;AAED,eAAe,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,122 @@
+/**
+ * @harpoon/monorepo
+ *
+ * Package-manager agnostic monorepo binding for Harpoon.
+ *
+ * Provides:
+ * - MonorepoBinding: Build-time transformations for monorepo structure
+ * - Build strategy for simulating monorepo structure
+ * - Dockerfile transformers for monorepo paths
+ *
+ * Note: This package does NOT assume any specific package manager.
+ * Users should configure their own root files (lock files, workspace configs).
+ */
+import { Effect } from 'effect';
+// Re-export transformers and strategies
+export { monorepoTransformers, monorepoRootFilesTransformer, monorepoCopyAllTransformer, monorepoDataPathTransformer, } from './transformers/monorepo';
+export { monorepoSimulationStrategy } from './strategies/monorepo-simulation';
+// ============ Binding Implementation ============
+/**
+ * Creates a Monorepo binding for build-time transformations.
+ *
+ * This binding provides:
+ * - Build context preparation (simulating monorepo structure)
+ * - Dockerfile transformations for monorepo paths
+ * - Config patching for pnpm workspaces
+ *
+ * @example
+ * ```typescript
+ * import { Image } from '@harpoon/core';
+ * import { MonorepoBinding } from '@harpoon/monorepo';
+ * import { NextjsBinding } from '@harpoon/nextjs';
+ *
+ * const appImage = await Image("my-app:latest", {
+ *   context: "./apps/web",
+ *   bindings: {
+ *     MONOREPO: MonorepoBinding({
+ *       appName: "web",
+ *       source: "../..",  // monorepo root
+ *     }),
+ *     NEXTJS: NextjsBinding({ standalone: true }),
+ *   },
+ * });
+ * ```
+ */
+export function MonorepoBinding(options) {
+    const { appName, source, sharedFolders, rootFiles } = options;
+    return {
+        type: 'monorepo',
+        resource: undefined,
+        getEnv() {
+            return {};
+        },
+        transformDockerfile(instructions, ctx) {
+            // Ensure context has appName
+            const monoCtx = {
+                ...ctx,
+                appName: appName || ctx.appName,
+            };
+            // Import and apply monorepo transformers
+            const { monorepoTransformers } = require('./transformers/monorepo');
+            let result = [...instructions];
+            for (const transformer of monorepoTransformers) {
+                result = result.flatMap((inst) => {
+                    if (!transformer.handlesTypes.includes(inst.type)) {
+                        return [inst];
+                    }
+                    if (!transformer.matches(inst, monoCtx)) {
+                        return [inst];
+                    }
+                    const transformed = transformer.transform(inst, monoCtx);
+                    return Array.isArray(transformed) ? [...transformed] : [transformed];
+                });
+            }
+            return result;
+        },
+        prepareBuildContext(input, ctx) {
+            // If already in a temp directory with apps/, no need to simulate
+            if (ctx.contextPath.includes('temp-build')) {
+                return Effect.succeed(ctx);
+            }
+            // Use the monorepo simulation strategy
+            const { monorepoSimulationStrategy } = require('./strategies/monorepo-simulation');
+            const enhancedInput = {
+                ...input,
+                monorepoAppName: appName,
+                ...(source !== undefined && { monorepoSource: source }),
+                options: {
+                    ...input.options,
+                    ...(sharedFolders && { sharedFolders }),
+                    ...(rootFiles && { rootFiles }),
+                },
+            };
+            return monorepoSimulationStrategy.prepare(enhancedInput);
+        },
+    };
+}
+// ============ Registration Helpers ============
+/**
+ * Register all monorepo plugins with Harpoon's registries.
+ *
+ * Call this once at application startup if you want the strategy,
+ * patchers, and transformers to be available globally.
+ *
+ * @example
+ * ```typescript
+ * import { registerMonorepoPlugins } from '@harpoon/monorepo';
+ *
+ * registerMonorepoPlugins();
+ * ```
+ */
+export function registerMonorepoPlugins() {
+    const core = require('@harpoon/core');
+    const { monorepoSimulationStrategy } = require('./strategies/monorepo-simulation');
+    const { monorepoTransformers } = require('./transformers/monorepo');
+    // Register build strategy
+    core.registerBuildStrategy(monorepoSimulationStrategy);
+    // Register transformers
+    for (const transformer of monorepoTransformers) {
+        core.registerTransformer(transformer);
+    }
+}
+export default MonorepoBinding;

package/dist/strategies/monorepo-simulation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Monorepo Simulation Build Strategy
+ *
+ * Creates a simulated monorepo structure in a temp directory.
+ * Copies app content to apps/{appName}, shared folders, and root files.
+ */
+import type { BuildStrategy } from '@harpoon/core';
+/**
+ * Monorepo simulation build strategy.
+ *
+ * Creates a temp directory with monorepo structure:
+ * - apps/{appName}/ - The app being built
+ * - packages/ - Shared packages
+ * - tools/ - Shared tools
+ * - Root files (package.json, pnpm-lock.yaml, etc.)
+ */
+export declare const monorepoSimulationStrategy: BuildStrategy;
+export default monorepoSimulationStrategy;
+//# sourceMappingURL=monorepo-simulation.d.ts.map

package/dist/strategies/monorepo-simulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monorepo-simulation.d.ts","sourceRoot":"","sources":["../../src/strategies/monorepo-simulation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAoC,MAAM,eAAe,CAAC;AAqGrF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,aAmGxC,CAAC;AAEF,eAAe,0BAA0B,CAAC"}

package/dist/strategies/monorepo-simulation.js

@@ -0,0 +1,144 @@
+/**
+ * Monorepo Simulation Build Strategy
+ *
+ * Creates a simulated monorepo structure in a temp directory.
+ * Copies app content to apps/{appName}, shared folders, and root files.
+ */
+import { Effect } from 'effect';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { BuildStrategyError } from '@harpoon/core';
+// ============ Configuration ============
+/**
+ * Default shared folders to copy from monorepo source.
+ */
+const DEFAULT_SHARED_FOLDERS = ['packages', 'tools'];
+/**
+ * Default root files to copy.
+ * Note: Intentionally minimal - users should specify their lock file.
+ */
+const DEFAULT_ROOT_FILES = ['package.json'];
+// ============ Helper Functions ============
+/**
+ * Recursively copy a directory.
+ */
+async function copyRecursive(src, dest) {
+    const proc = Bun.spawn(['cp', '-R', src, dest], {
+        stdout: 'ignore',
+        stderr: 'inherit',
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+        throw new Error(`Failed to copy ${src} to ${dest}`);
+    }
+}
+/**
+ * Copy shared folders to temp directory.
+ */
+async function copySharedFolders(sharedSource, tempDir, folders) {
+    const copiedFolders = [];
+    for (const folder of folders) {
+        const sourcePath = path.join(sharedSource, folder);
+        try {
+            await fs.access(sourcePath);
+            console.log(`[BuildStrategy:monorepo-simulation] Copying ${folder} from ${sharedSource}...`);
+            await copyRecursive(sourcePath, path.join(tempDir, folder));
+            copiedFolders.push(folder);
+        }
+        catch {
+            console.warn(`[BuildStrategy:monorepo-simulation] Warning: ${folder} not found in ${sharedSource}`);
+        }
+    }
+    return Object.freeze(copiedFolders);
+}
+/**
+ * Copy root files to temp directory.
+ */
+async function copyRootFiles(context, sharedSource, tempDir, files) {
+    const copiedFiles = [];
+    for (const file of files) {
+        // Try app context first
+        let sourcePath = path.join(context, file);
+        try {
+            await fs.access(sourcePath);
+            await fs.copyFile(sourcePath, path.join(tempDir, file));
+            copiedFiles.push(file);
+            continue;
+        }
+        catch {
+            // Fall through to try shared source
+        }
+        // Try shared source
+        sourcePath = path.join(sharedSource, file);
+        try {
+            await fs.access(sourcePath);
+            console.log(`[BuildStrategy:monorepo-simulation] Copying ${file} from ${sharedSource}...`);
+            await fs.copyFile(sourcePath, path.join(tempDir, file));
+            copiedFiles.push(file);
+        }
+        catch {
+            console.warn(`[BuildStrategy:monorepo-simulation] Warning: ${file} not found in ${context} or ${sharedSource}`);
+        }
+    }
+    return Object.freeze(copiedFiles);
+}
+// ============ Strategy Implementation ============
+/**
+ * Monorepo simulation build strategy.
+ *
+ * Creates a temp directory with monorepo structure:
+ * - apps/{appName}/ - The app being built
+ * - packages/ - Shared packages
+ * - tools/ - Shared tools
+ * - Root files (package.json, pnpm-lock.yaml, etc.)
+ */
+export const monorepoSimulationStrategy = {
+    name: 'monorepo-simulation',
+    description: 'Simulates monorepo structure in temp directory',
+    prepare: (input) => Effect.gen(function* () {
+        if (!input.monorepoAppName) {
+            yield* Effect.fail(new BuildStrategyError('monorepo-simulation', 'monorepoAppName is required for monorepo-simulation strategy'));
+        }
+        const appName = input.monorepoAppName;
+        const tempDir = path.resolve(process.cwd(), 'temp-build', input.tag.replace(':', '_'));
+        const sharedSource = input.monorepoSource ?? input.context;
+        // Get configurable options or use defaults
+        const sharedFolders = input.options?.sharedFolders ?? DEFAULT_SHARED_FOLDERS;
+        const rootFiles = input.options?.rootFiles ?? DEFAULT_ROOT_FILES;
+        // Clean and create temp directory
+        yield* Effect.tryPromise({
+            try: () => fs.rm(tempDir, { recursive: true, force: true }),
+            catch: (error) => new BuildStrategyError('monorepo-simulation', `Failed to clean temp directory: ${error}`, error instanceof Error ? error : undefined),
+        });
+        yield* Effect.tryPromise({
+            try: () => fs.mkdir(path.join(tempDir, 'apps'), { recursive: true }),
+            catch: (error) => new BuildStrategyError('monorepo-simulation', `Failed to create temp directory: ${error}`, error instanceof Error ? error : undefined),
+        });
+        // Copy app content
+        console.log(`[BuildStrategy:monorepo-simulation] Copying app content from ${input.context} to ${path.join(tempDir, 'apps', appName)}...`);
+        yield* Effect.tryPromise({
+            try: () => copyRecursive(input.context, path.join(tempDir, 'apps', appName)),
+            catch: (error) => new BuildStrategyError('monorepo-simulation', `Failed to copy app content: ${error}`, error instanceof Error ? error : undefined),
+        });
+        // Copy shared folders
+        yield* Effect.tryPromise({
+            try: () => copySharedFolders(sharedSource, tempDir, sharedFolders),
+            catch: (error) => new BuildStrategyError('monorepo-simulation', `Failed to copy shared folders: ${error}`, error instanceof Error ? error : undefined),
+        });
+        // Copy root files
+        yield* Effect.tryPromise({
+            try: () => copyRootFiles(input.context, sharedSource, tempDir, rootFiles),
+            catch: (error) => new BuildStrategyError('monorepo-simulation', `Failed to copy root files: ${error}`, error instanceof Error ? error : undefined),
+        });
+        const dockerfilePath = path.join(tempDir, 'apps', appName, 'Dockerfile');
+        console.log(`[BuildStrategy:monorepo-simulation] Simulating monorepo for ${input.tag} in ${tempDir}`);
+        const result = {
+            contextPath: tempDir,
+            dockerfilePath,
+            requiresCleanup: true,
+            tempDir,
+        };
+        return result;
+    }),
+};
+export default monorepoSimulationStrategy;

package/dist/transformers/monorepo.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Monorepo Dockerfile Transformers
+ *
+ * Transforms for converting standalone Dockerfiles to monorepo structure.
+ * Handles COPY commands and build context transformations.
+ */
+import type { InstructionTransformer } from '@harpoon/core';
+/**
+ * Transforms COPY commands for root package files.
+ * Matches when copying package.json with any lock file.
+ * Supports: pnpm-lock.yaml, package-lock.json, yarn.lock, bun.lockb
+ */
+export declare const monorepoRootFilesTransformer: InstructionTransformer;
+/**
+ * Transforms COPY . . to copy individual folders.
+ */
+export declare const monorepoCopyAllTransformer: InstructionTransformer;
+/**
+ * Skips database data paths (keeps them as-is).
+ * This is a "passthrough" transformer that prevents other transformers
+ * from modifying database paths.
+ */
+export declare const monorepoDataPathTransformer: InstructionTransformer;
+/**
+ * All monorepo transformers for easy registration.
+ */
+export declare const monorepoTransformers: readonly InstructionTransformer[];
+export default monorepoTransformers;
+//# sourceMappingURL=monorepo.d.ts.map

package/dist/transformers/monorepo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monorepo.d.ts","sourceRoot":"","sources":["../../src/transformers/monorepo.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAA2C,MAAM,eAAe,CAAC;AAKrG;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,sBA0B1C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,sBA4BxC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,EAAE,sBAiBzC,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,sBAAsB,EAIhE,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/transformers/monorepo.js

@@ -0,0 +1,92 @@
+/**
+ * Monorepo Dockerfile Transformers
+ *
+ * Transforms for converting standalone Dockerfiles to monorepo structure.
+ * Handles COPY commands and build context transformations.
+ */
+import { replaceInstruction, splitInstruction } from '@harpoon/core';
+// ============ Transformers ============
+/**
+ * Transforms COPY commands for root package files.
+ * Matches when copying package.json with any lock file.
+ * Supports: pnpm-lock.yaml, package-lock.json, yarn.lock, bun.lockb
+ */
+export const monorepoRootFilesTransformer = {
+    name: 'monorepo-root-files',
+    description: 'Transforms COPY for root package files in monorepo',
+    handlesTypes: ['COPY'],
+    matches: (inst, _ctx) => {
+        const arg = inst.args[0] || '';
+        // Must have package.json
+        if (!arg.includes('package.json'))
+            return false;
+        // Must have some lock file (any package manager)
+        return (arg.includes('pnpm-lock.yaml') ||
+            arg.includes('package-lock.json') ||
+            arg.includes('yarn.lock') ||
+            arg.includes('bun.lockb'));
+    },
+    transform: (inst, ctx) => {
+        const rootFiles = ctx.copiedRootFiles.join(' ');
+        return replaceInstruction(inst, `COPY ${rootFiles} ./`, Object.freeze([rootFiles, './']));
+    },
+};
+/**
+ * Transforms COPY . . to copy individual folders.
+ */
+export const monorepoCopyAllTransformer = {
+    name: 'monorepo-copy-all',
+    description: 'Transforms COPY . . to copy individual folders for monorepo',
+    handlesTypes: ['COPY'],
+    matches: (inst, _ctx) => {
+        return inst.args[0] === '.' && inst.args[1] === '.';
+    },
+    transform: (inst, ctx) => {
+        const replacements = [];
+        // Add COPY for each shared folder
+        for (const folder of ctx.copiedFolders) {
+            replacements.push({
+                original: `COPY ${folder} ./${folder}`,
+                args: Object.freeze([folder, `./${folder}`]),
+            });
+        }
+        // Add COPY for the app folder
+        replacements.push({
+            original: `COPY apps/${ctx.appName} ./apps/${ctx.appName}`,
+            args: Object.freeze([`apps/${ctx.appName}`, `./apps/${ctx.appName}`]),
+        });
+        return splitInstruction(inst, replacements);
+    },
+};
+/**
+ * Skips database data paths (keeps them as-is).
+ * This is a "passthrough" transformer that prevents other transformers
+ * from modifying database paths.
+ */
+export const monorepoDataPathTransformer = {
+    name: 'monorepo-data-path',
+    description: 'Preserves /app/data/ paths without transformation',
+    handlesTypes: ['COPY'],
+    matches: (inst, ctx) => {
+        if (!ctx.currentStage?.toLowerCase().includes('runner'))
+            return false;
+        if (!inst.args[0]?.includes('--from=builder'))
+            return false;
+        const sourcePath = inst.args[1];
+        return sourcePath?.includes('/app/data/') || false;
+    },
+    transform: (inst, _ctx) => {
+        // Return unchanged - this prevents other transformers from modifying it
+        return inst;
+    },
+};
+// ============ Exports ============
+/**
+ * All monorepo transformers for easy registration.
+ */
+export const monorepoTransformers = Object.freeze([
+    monorepoRootFilesTransformer,
+    monorepoCopyAllTransformer,
+    monorepoDataPathTransformer,
+]);
+export default monorepoTransformers;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@docker-harpoon/monorepo",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Monorepo binding for Harpoon - package-manager agnostic build context simulation",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "effect": "^3.19.14"
+  },
+  "peerDependencies": {
+    "@docker-harpoon/core": ">=0.1.0",
+    "bun": ">=1.0.0"
+  }
+}