create-next-hydra 0.3.0 → 0.4.2

package/dist/workspaces.js

@@ -0,0 +1,396 @@
+import { Array as EffectArray, Cause, Context, Effect, FileSystem, Layer, Order, Path, Redacted, Schema, Fiber, Queue, Ref, Result, Stream, } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { existingWorkspace } from "./addition.js";
+import { initializeApplicationGit } from "./application-git.js";
+import { Composition } from "./composition.js";
+import { planEnvironmentCopy, copyEnvironment } from "./environment.js";
+import { DestinationNotEmpty, InvalidComposition, MaterializationFailed, SourceChanged, SnapshotUnavailable, WorkspaceRecoveryRequired, WorkspaceUninitialized, } from "./errors.js";
+import { relativeFile, writeFile } from "./files.js";
+import { inspectInitialization, listUnregisteredFiles, namedInitializationFiles, validatePreservedFiles, workspaceSetting, } from "./initialization.js";
+import { WorkspaceDefinition } from "./model.js";
+import { Shadcn } from "./shadcn.js";
+import { SourceChanges, SourceWatchFailure } from "./source-changes.js";
+import { SourceInventory } from "./source-inventory.js";
+import { WorkspaceDependencies } from "./workspace-dependencies.js";
+import { WorkspaceFiles } from "./workspace-files.js";
+import { WorkspaceSnapshots, snapshotTarget } from "./workspace-snapshots.js";
+import { WorkspaceSources } from "./workspace-sources.js";
+import { WorkspaceState } from "./workspace-state.js";
+export class Workspaces extends Context.Service()("create-next-hydra/Workspaces") {
+    static layer = Layer.effect(Workspaces, Effect.gen(function* () {
+        const sources = yield* WorkspaceSources;
+        const composition = yield* Composition;
+        const inventory = yield* SourceInventory;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const state = yield* WorkspaceState;
+        const workspaceFiles = yield* WorkspaceFiles;
+        const dependencies = yield* WorkspaceDependencies;
+        const snapshots = yield* WorkspaceSnapshots;
+        const sourceChanges = yield* SourceChanges;
+        const processes = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const shadcn = yield* Shadcn;
+        const initialize = Effect.fn("Workspaces.initialize")((request) => Effect.sync(() => {
+            const destination = path.resolve(request.destination);
+            const inspect = inspectInitialization(destination).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+            return {
+                materialize: Effect.fn("FreshWorkspace.materialize")(function* (options) {
+                    if (request.source.kind === "working-tree" &&
+                        destination === path.resolve(request.source.root)) {
+                        return yield* new InvalidComposition({
+                            message: "Source and destination must differ",
+                        });
+                    }
+                    yield* inspect;
+                    const prepared = yield* sources.use(request.source, (source) => composition.prepare({
+                        name: request.name,
+                        selection: request.selection,
+                        source,
+                    }));
+                    yield* inspect;
+                    const { files } = prepared;
+                    for (const file of files) {
+                        if (yield* fs.exists(path.join(destination, file.target))) {
+                            return yield* new DestinationNotEmpty({
+                                directory: destination,
+                            });
+                        }
+                    }
+                    const environment = yield* planEnvironmentCopy(destination, files, options.environment === "copy-missing-local" &&
+                        request.source.kind === "working-tree"
+                        ? yield* inventory.localEnvironment(request.source.root)
+                        : []).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+                    yield* fs
+                        .makeDirectory(destination, { recursive: true })
+                        .pipe(Effect.uninterruptible);
+                    const completedFiles = [];
+                    for (const file of files) {
+                        yield* writeFile(destination, file, true).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.mapError((error) => new MaterializationFailed({
+                            completedFiles: [...completedFiles],
+                            diagnostic: Redacted.make(error),
+                            directory: destination,
+                            failedFile: file.target,
+                        })));
+                        completedFiles.push(file.target);
+                    }
+                    const environmentFilesCreated = yield* copyEnvironment(destination, environment).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+                    const dependencyResult = yield* dependencies.reconcile(destination, files, options);
+                    const git = options.git && options.git !== "skip"
+                        ? yield* initializeApplicationGit(destination, options.git === "commit").pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, processes))
+                        : undefined;
+                    const result = {
+                        ...dependencyResult,
+                        destination,
+                        environmentFilesCreated,
+                        files: files.map((file) => file.target),
+                        instructions: prepared.instructions,
+                        origins: files.map(({ target, origin }) => ({
+                            origin,
+                            target,
+                        })),
+                        removedFiles: [],
+                    };
+                    return git === undefined ? result : { ...result, git };
+                }),
+            };
+        }));
+        const fresh = Effect.fn("Workspaces.fresh")((request) => initialize(request));
+        const named = Effect.fn("Workspaces.named")(function* ({ sourceRoot, name, }) {
+            if (!/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u.test(name)) {
+                return yield* new InvalidComposition({
+                    message: "Workspace name must contain 1–63 lowercase letters, digits or hyphens, beginning and ending with a letter or digit",
+                });
+            }
+            const destination = path.resolve(sourceRoot, "workspaces", name);
+            const definitionPath = path.join(destination, "next-hydra.json");
+            const readDefinition = Effect.gen(function* () {
+                const definition = yield* fs.readFileString(definitionPath);
+                const parsed = yield* Schema.decodeEffect(Schema.fromJsonString(WorkspaceDefinition))(definition, { onExcessProperty: "error" });
+                yield* validatePreservedFiles(parsed.preserve);
+                return {
+                    definition,
+                    port: parsed.development?.port,
+                    preserve: parsed.preserve,
+                    demoArchitecture: parsed.demo?.architecture,
+                    selection: { addOns: parsed.addOns, providers: parsed.providers },
+                };
+            });
+            const operations = {
+                check: state
+                    .withRead({ directory: destination, sourceRoot }, (observation) => Effect.gen(function* () {
+                    if (observation.pending !== null &&
+                        (observation.pending.kind !== "installation" ||
+                            !observation.pending.stopped)) {
+                        return yield* new WorkspaceRecoveryRequired({
+                            directory: destination,
+                        });
+                    }
+                    const { definition, port, preserve, selection, demoArchitecture, } = yield* readDefinition;
+                    const prepared = yield* sources.use({ kind: "working-tree", root: sourceRoot }, (source) => composition.prepare({
+                        name,
+                        port,
+                        selection,
+                        source,
+                        demoArchitecture,
+                    }));
+                    const preserved = yield* inspectInitialization(destination, definition);
+                    const output = yield* namedInitializationFiles(prepared.files, preserved, preserve);
+                    const files = output.filter((file) => file.target !== ".gitignore");
+                    const changes = [
+                        ...(yield* workspaceFiles.inspect(observation, files, preserve)),
+                    ];
+                    if (!preserved.has(".gitignore")) {
+                        changes.push({ kind: "setting", target: ".gitignore" });
+                    }
+                    if ((yield* fs.readFileString(definitionPath)) !== definition) {
+                        return yield* new SourceChanged({
+                            paths: ["next-hydra.json"],
+                        });
+                    }
+                    return {
+                        changes,
+                        destination,
+                        initialized: observation.initialized,
+                        ready: observation.initialized && changes.length === 0,
+                    };
+                }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)), { allowIncomplete: true })
+                    .pipe(Effect.withSpan("NamedWorkspace.check")),
+                diff: state
+                    .withRead({ directory: destination, sourceRoot }, (observation) => Effect.gen(function* () {
+                    if (!observation.initialized) {
+                        return yield* new WorkspaceUninitialized({
+                            directory: destination,
+                        });
+                    }
+                    if (!observation.snapshot) {
+                        return yield* new SnapshotUnavailable({
+                            directory: destination,
+                        });
+                    }
+                    const pending = observation.pending?.kind === "files"
+                        ? observation.pending.files
+                        : [];
+                    const targets = [
+                        ...new Set([
+                            ...observation.entries.map((entry) => entry.target),
+                            ...pending.map((entry) => entry.target),
+                        ]),
+                    ];
+                    const owned = new Set([
+                        ...targets,
+                        ...observation.preserved,
+                        ...pending.flatMap((entry) => entry.temporary === null ? [] : [entry.temporary]),
+                    ]);
+                    const unregisteredFiles = yield* listUnregisteredFiles(destination, owned);
+                    const { files, conflicts } = yield* workspaceFiles.read(destination, targets);
+                    const comparison = yield* snapshots.diff({ directory: destination, sourceRoot }, observation.snapshot.commit, files);
+                    return {
+                        ...comparison,
+                        conflicts,
+                        incomplete: observation.revision !== observation.snapshot.revision,
+                        origins: observation.snapshot.origins.filter((file) => comparison.changes.some((change) => change.target === file.target)),
+                        snapshot: observation.snapshot.commit,
+                        unregisteredFiles: unregisteredFiles.filter((target) => snapshotTarget(target) && !conflicts.includes(target)),
+                    };
+                }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)), { allowIncomplete: true })
+                    .pipe(Effect.withSpan("NamedWorkspace.diff")),
+                explain: Effect.fn("NamedWorkspace.explain")(function* (target) {
+                    const selectedTarget = target === undefined ? undefined : yield* relativeFile(target);
+                    const { definition, port, selection, demoArchitecture } = yield* readDefinition;
+                    const prepared = yield* sources.use({ kind: "working-tree", root: sourceRoot }, (source) => composition.prepare({
+                        name,
+                        port,
+                        selection,
+                        source,
+                        demoArchitecture,
+                    }));
+                    const files = prepared.files
+                        .filter((file) => !workspaceSetting(file.target) &&
+                        (selectedTarget === undefined ||
+                            file.target === selectedTarget))
+                        .map(({ target: file, origin }) => ({ origin, target: file }));
+                    if (selectedTarget !== undefined &&
+                        workspaceSetting(selectedTarget) &&
+                        (yield* fs.exists(path.join(destination, selectedTarget))) &&
+                        (yield* fs.stat(path.join(destination, selectedTarget))).type ===
+                            "File") {
+                        files.push({
+                            origin: {
+                                kind: "workspace-setting",
+                                source: `workspaces/${name}/${selectedTarget}`,
+                            },
+                            target: selectedTarget,
+                        });
+                    }
+                    if (selectedTarget !== undefined && files.length === 0) {
+                        return yield* new InvalidComposition({
+                            message: `No selected composition file: ${selectedTarget}`,
+                        });
+                    }
+                    if ((yield* fs.readFileString(definitionPath)) !== definition) {
+                        return yield* new SourceChanged({ paths: ["next-hydra.json"] });
+                    }
+                    return { destination, files, sourceRoot: path.resolve(sourceRoot) };
+                }),
+                sync: Effect.fn("NamedWorkspace.sync")(function* (options, environmentCopied = Effect.void, observeInputs = () => Effect.succeed(false)) {
+                    return yield* state.withWrite({ directory: destination, sourceRoot }, (access) => Effect.gen(function* () {
+                        const { definition, port, preserve, selection, demoArchitecture, } = yield* readDefinition;
+                        const inspect = inspectInitialization(destination, definition);
+                        yield* dependencies.recover(access);
+                        yield* workspaceFiles.recover(access);
+                        yield* inspect;
+                        const prepare = sources.use({ kind: "working-tree", root: sourceRoot }, (source) => composition.prepare({
+                            name,
+                            port,
+                            selection,
+                            source,
+                            demoArchitecture,
+                        }));
+                        let prepared = yield* prepare;
+                        // Watch may discover inputs beyond its connected roots. Subscribe
+                        // and re-read them before applying any output from that discovery.
+                        while (yield* observeInputs(prepared.inputs)) {
+                            prepared = yield* prepare;
+                        }
+                        const preserved = yield* inspect;
+                        const output = yield* namedInitializationFiles(prepared.files, preserved, preserve);
+                        // Ignore rules are seeded once and become workspace-owned settings.
+                        const settings = output.filter((file) => file.target === ".gitignore");
+                        const files = output.filter((file) => file.target !== ".gitignore");
+                        const environment = yield* planEnvironmentCopy(destination, files, options.environment === "copy-missing-local"
+                            ? yield* inventory.localEnvironment(sourceRoot)
+                            : []);
+                        const applied = yield* workspaceFiles.apply(access, files, [
+                            ...settings.map((file) => file.target),
+                            ...environment.map((file) => file.target),
+                        ], preserve);
+                        for (const setting of settings) {
+                            yield* access.initialize(setting.target, writeFile(destination, setting, true));
+                        }
+                        const environmentFilesCreated = yield* copyEnvironment(destination, environment, access.initialize);
+                        yield* environmentCopied;
+                        yield* inspect;
+                        yield* applied.complete;
+                        const dependencyState = yield* dependencies.reconcile(destination, files, options, access);
+                        const observation = yield* access.observation;
+                        const captured = yield* workspaceFiles.capture(destination, observation.entries);
+                        const commit = yield* snapshots.capture({ directory: destination, sourceRoot }, captured, observation.snapshot?.commit);
+                        // Reobserve against the same applied fingerprints before the
+                        // receipt selects these immutable bytes as its baseline.
+                        yield* workspaceFiles.capture(destination, observation.entries);
+                        yield* access.publishSnapshot(commit, observation.revision);
+                        return {
+                            ...dependencyState,
+                            destination,
+                            environmentFilesCreated,
+                            files: files.map((file) => file.target),
+                            instructions: prepared.instructions,
+                            origins: prepared.files
+                                .filter((file) => workspaceSetting(file.target) === undefined)
+                                .map(({ target, origin }) => ({ origin, target })),
+                            recoveryEvidence: access.recoveryEvidence,
+                            removedFiles: applied.removedFiles,
+                        };
+                    }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)), options);
+                }),
+            };
+            return {
+                ...operations,
+                watch: (options) => Stream.unwrap(Effect.gen(function* () {
+                    const coverage = (inputs) => ({
+                        files: [`workspaces/${name}/next-hydra.json`],
+                        inputs,
+                        root: path.resolve(sourceRoot),
+                    });
+                    const subscription = yield* sourceChanges.open(coverage(null));
+                    const pending = yield* Queue.dropping(1);
+                    const copied = yield* Ref.make(false);
+                    let observedExternal = new Set();
+                    const collector = yield* subscription.invalidations.pipe(Stream.runForEach(() => Queue.offer(pending, undefined)), Effect.andThen(Effect.fail(new SourceWatchFailure({
+                        diagnostic: Redacted.make("Observation ended unexpectedly"),
+                        path: sourceRoot,
+                        phase: "observe",
+                    }))), Effect.forkScoped);
+                    const synchronize = Effect.gen(function* () {
+                        // Observe discoveries before reading any newly selected input.
+                        // Failed preparation keeps this conservative scope for repair.
+                        yield* subscription.update(coverage(null));
+                        const inputs = yield* Ref.make(null);
+                        const outcome = yield* operations
+                            .sync({
+                            ...options,
+                            environment: (yield* Ref.get(copied))
+                                ? "preserve"
+                                : options.environment,
+                        }, Ref.set(copied, true), (prepared) => Effect.gen(function* () {
+                            yield* Ref.set(inputs, prepared);
+                            yield* subscription.update(coverage(prepared));
+                            const external = prepared.files.filter((file) => file.startsWith("../") || path.isAbsolute(file));
+                            const discovered = external.some((file) => !observedExternal.has(file));
+                            observedExternal = new Set(external);
+                            if (discovered) {
+                                yield* Ref.set(inputs, null);
+                                yield* subscription.update(coverage(null));
+                            }
+                            return discovered;
+                        }))
+                            .pipe(Effect.matchCauseEffect({
+                            onFailure: (cause) => {
+                                if (Cause.hasDies(cause) ||
+                                    Cause.hasInterrupts(cause)) {
+                                    return Effect.failCause(cause);
+                                }
+                                const failure = Cause.findError(cause);
+                                if (Result.isFailure(failure)) {
+                                    return Effect.failCause(failure.failure);
+                                }
+                                const error = failure.success;
+                                if (error._tag === "SourceWatchFailure") {
+                                    return Effect.failCause(cause);
+                                }
+                                return Effect.succeed({
+                                    _tag: "RefreshFailed",
+                                    error,
+                                });
+                            },
+                            onSuccess: (result) => Effect.succeed({
+                                _tag: "Synchronized",
+                                result,
+                            }),
+                        }));
+                        yield* subscription.update(coverage(yield* Ref.get(inputs)));
+                        return outcome;
+                    });
+                    const subsequent = Effect.gen(function* () {
+                        yield* Queue.take(pending);
+                        yield* Effect.sleep("50 millis");
+                        yield* Queue.clear(pending);
+                        return yield* synchronize;
+                    });
+                    return Stream.concat(Stream.fromEffect(synchronize), Stream.fromEffectRepeat(subsequent)).pipe(Stream.interruptWhen(Fiber.join(collector)));
+                })),
+            };
+        });
+        const discover = Effect.fn("Workspaces.discover")(function* (sourceRoot) {
+            const root = path.resolve(sourceRoot);
+            const references = [];
+            for (const file of yield* inventory.list(root)) {
+                const [directory, name, definition, extra] = file.split("/");
+                if (directory === "workspaces" &&
+                    name &&
+                    !name.startsWith(".") &&
+                    definition === "next-hydra.json" &&
+                    extra === undefined) {
+                    references.push({ name, sourceRoot: root });
+                }
+            }
+            return EffectArray.sortWith(references, (reference) => reference.name, Order.String);
+        });
+        return Workspaces.of({
+            discover,
+            existing: ({ root }) => existingWorkspace(root).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.provideService(Shadcn, shadcn), Effect.provideService(WorkspaceDependencies, dependencies)),
+            fresh,
+            named,
+        });
+    }));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-next-hydra",
-  "version": "0.3.0",
-  "description": "CLI to scaffold a new next-hydra project",
+  "version": "0.4.2",
+  "description": "CLI to compose applications from the Next Hydra registry",
   "keywords": [
     "cli",
     "create-next-app",
@@ -23,6 +23,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./reference-workspace": {
+      "types": "./dist/reference-workspace-bindings.d.ts",
+      "import": "./dist/reference-workspace-bindings.js"
+    },
     "./cli": {
       "import": "./dist/cli.js"
     }
@@ -37,24 +41,21 @@
     "schema"
   ],
   "dependencies": {
-    "@clack/prompts": "^0.11.0",
-    "commander": "^14.0.0",
+    "@effect/platform-node": "4.0.0-rc.117",
+    "@effect/platform-node-shared": "4.0.0-rc.117",
+    "@parcel/watcher": "^2.6.0",
+    "effect": "4.0.0-rc.117",
     "jsonc-parser": "^3.3.1",
+    "oxfmt": "0.61.0",
     "shadcn": "^4.16.2",
-    "yaml": "^2.9.0",
-    "zod": "^3.25.28"
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.117",
     "@types/node": "24.13.3",
-    "effect": "4.0.0-rc.111",
-    "typescript": "npm:@typescript/typescript6@6.0.2",
-    "vitest": "4.1.11",
-    "@repo/actions": "0.0.0",
-    "@repo/auth-workos": "0.0.0",
-    "@repo/auth-clerk": "0.0.0",
-    "@repo/commerce": "0.0.0",
-    "@repo/typescript-config": "0.0.0",
-    "@repo/registration": "0.0.0"
+    "vitest": "5.0.1",
+    "@repo/typescript-config": "0.0.0"
   },
   "engines": {
     "node": "24.x"
@@ -64,12 +65,18 @@
   },
   "scripts": {
     "prebuild": "node scripts/clean-dist.js",
-    "build": "tsc -p tsconfig.json",
-    "pack": "npm pack",
-    "publish:dry-run": "npm publish --access public --dry-run",
-    "publish:public": "npm publish --access public",
+    "build": "tsc6 -p tsconfig.json",
+    "compose": "pnpm --workspace-root exec turbo run build --filter=create-next-hydra && node dist/cli.js compose",
+    "pack": "pnpm pack",
+    "publish:dry-run": "pnpm publish --access public --dry-run",
+    "publish:public": "pnpm publish --access public",
     "test": "NODE_ENV=test vitest run --exclude 'tests/e2e/**'",
+    "pretest:e2e": "pnpm run build",
     "test:e2e": "NODE_ENV=test vitest run tests/e2e",
-    "typecheck": "pnpm --workspace-root exec tsc --noEmit --project packages/create-next-hydra/tsconfig.json"
+    "typecheck": "tsc6 --noEmit -p tsconfig.json && tsc6 -p tsconfig.tests.json",
+    "workspace:test": "node dist/test-reference-workspace.js",
+    "workspace:lint": "node dist/lint-workspaces.js",
+    "lint:staged": "pnpm run build && node dist/lint-workspaces.js --staged",
+    "test:package": "node scripts/check-package.mjs"
   }
 }