create-next-hydra 0.3.0 → 0.4.1

package/dist/packages.d.ts

@@ -0,0 +1,57 @@
+import { Effect, Schema } from "effect";
+import type { PlatformError } from "effect";
+import type { RegistryItem } from "shadcn/schema";
+import { InvalidComposition } from "./errors.ts";
+declare const Manifest: Schema.StructWithRest<Schema.Struct<{
+    readonly dependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly devDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly optionalDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly peerDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export declare const ManifestJson: Schema.fromJsonString<Schema.StructWithRest<Schema.Struct<{
+    readonly dependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly devDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly optionalDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly peerDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+export declare const DependencySection: Schema.Literals<readonly ["dependencies", "devDependencies", "optionalDependencies"]>;
+export interface PackageRequirement {
+    readonly target: string;
+    readonly section: typeof DependencySection.Type;
+    readonly name: string;
+    readonly specifier: string;
+}
+export type PackageRequirementTarget = Omit<PackageRequirement, "specifier">;
+type RegistryRequirements = Pick<RegistryItem, "name" | "dependencies" | "devDependencies">;
+interface RootRequirement {
+    readonly name: string;
+    readonly section: "dependencies" | "devDependencies";
+    readonly specifier: string | undefined;
+}
+export declare const registryDependencies: (items: readonly RegistryRequirements[]) => Effect.Effect<RootRequirement[], InvalidComposition, never>;
+interface CapturedFile {
+    readonly content: Uint8Array;
+    readonly mode: number;
+}
+type Capture = (file: string) => Effect.Effect<CapturedFile, PlatformError.PlatformError | InvalidComposition>;
+export declare function internalDependencies(manifest: typeof Manifest.Type): string[];
+interface PackageInputs {
+    readonly omittedDependencies?: ReadonlySet<string>;
+    readonly files: readonly string[];
+    readonly packageManifests: readonly string[];
+    readonly selectedManifests: ReadonlyMap<string, CapturedFile>;
+    readonly governed: ReadonlySet<string>;
+    readonly capture: Capture;
+    readonly requirements: readonly PackageRequirement[];
+    readonly ownedRequirements: readonly PackageRequirementTarget[];
+    readonly registryItems: readonly RegistryRequirements[];
+}
+export declare const completePackages: (args_0: PackageInputs) => Effect.Effect<{
+    baseline: Set<string>;
+    directories: string[];
+    manifests: Map<string, CapturedFile>;
+}, InvalidComposition | Schema.SchemaError | PlatformError.PlatformError, never>;
+export {};
+//# sourceMappingURL=packages.d.ts.map

package/dist/packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packages.d.ts","sourceRoot":"","sources":["../src/packages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIjD,QAAA,MAAM,QAAQ;;;;;;6DASb,CAAC;AACF,eAAO,MAAM,YAAY;;;;;;8DAAgD,CAAC;AAE1E,eAAO,MAAM,iBAAiB,uFAI5B,CAAC;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,iBAAiB,CAAC,IAAI,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACD,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;AAE7E,KAAK,oBAAoB,GAAG,IAAI,CAC9B,YAAY,EACZ,MAAM,GAAG,cAAc,GAAG,iBAAiB,CAC5C,CAAC;AACF,UAAU,eAAe;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CAAC;IACrD,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAED,eAAO,MAAM,oBAAoB,yGA0C/B,CAAC;AAuCH,UAAU,YAAY;IACpB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AACD,KAAK,OAAO,GAAG,CACb,IAAI,EAAE,MAAM,KACT,MAAM,CAAC,MAAM,CAChB,YAAY,EACZ,aAAa,CAAC,aAAa,GAAG,kBAAkB,CACjD,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,QAAQ,CAAC,IAAI,GAAG,MAAM,EAAE,CAkB7E;AAED,UAAU,aAAa;IACrB,QAAQ,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACrD,QAAQ,CAAC,iBAAiB,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAChE,QAAQ,CAAC,aAAa,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACzD;AAED,eAAO,MAAM,gBAAgB;;;;gFA2L5B,CAAC"}

package/dist/packages.js

@@ -0,0 +1,237 @@
+import { Array as EffectArray, Effect, Order, Schema } from "effect";
+import { InvalidComposition } from "./errors.js";
+import { eligiblePackageFile } from "./file-policy.js";
+const Dependencies = Schema.Record(Schema.String, Schema.String);
+const Manifest = Schema.StructWithRest(Schema.Struct({
+    dependencies: Schema.optionalKey(Dependencies),
+    devDependencies: Schema.optionalKey(Dependencies),
+    name: Schema.optionalKey(Schema.String),
+    optionalDependencies: Schema.optionalKey(Dependencies),
+    peerDependencies: Schema.optionalKey(Dependencies),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+export const ManifestJson = Schema.fromJsonString(Manifest, { space: 2 });
+export const DependencySection = Schema.Literals([
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+]);
+export const registryDependencies = Effect.fn("Composition.registryDependencies")(function* (items) {
+    const requirements = new Map();
+    for (const item of items) {
+        for (const section of ["dependencies", "devDependencies"]) {
+            for (const request of item[section] ?? []) {
+                const match = /^(?<name>(?:@[a-z0-9~][a-z0-9._~-]*\/)?[a-z0-9~][a-z0-9._~-]*)(?:@(?<specifier>\S+))?$/iu.exec(request);
+                const name = match?.groups?.name;
+                const specifier = match?.groups?.specifier;
+                if (!name) {
+                    return yield* new InvalidComposition({
+                        message: `${item.name}.${section} requires explicit package names: use name or name@specifier, not unnamed URLs or paths`,
+                    });
+                }
+                const previous = requirements.get(name);
+                if (previous?.specifier &&
+                    specifier &&
+                    previous.specifier !== specifier) {
+                    return yield* new InvalidComposition({
+                        message: `Conflicting registry dependency: ${name} (${item.name})`,
+                    });
+                }
+                requirements.set(name, {
+                    name,
+                    section: previous?.section === "dependencies" ? "dependencies" : section,
+                    specifier: previous?.specifier ?? specifier,
+                });
+            }
+        }
+    }
+    return EffectArray.sortWith([...requirements.values()], (requirement) => requirement.name, Order.String);
+});
+function applyRegistryDependencies(manifest, requirements) {
+    const output = { ...manifest };
+    for (const { name, section, specifier } of requirements) {
+        if (!specifier &&
+            [
+                output.dependencies,
+                output.devDependencies,
+                output.optionalDependencies,
+                output.peerDependencies,
+            ].some((entries) => Object.hasOwn(entries ?? {}, name))) {
+            continue;
+        }
+        const destination = section === "devDependencies" &&
+            Object.hasOwn(output.dependencies ?? {}, name)
+            ? "dependencies"
+            : section;
+        output[destination] = {
+            ...output[destination],
+            [name]: specifier ?? "latest",
+        };
+        const other = destination === "dependencies" ? "devDependencies" : "dependencies";
+        if (output[other]) {
+            output[other] = Object.fromEntries(Object.entries(output[other]).filter(([key]) => key !== name));
+        }
+    }
+    return output;
+}
+export function internalDependencies(manifest) {
+    return [
+        manifest.dependencies,
+        manifest.devDependencies,
+        manifest.optionalDependencies,
+        manifest.peerDependencies,
+    ].flatMap((section) => Object.entries(section ?? {}).flatMap(([name, specifier]) => {
+        if (!specifier.startsWith("workspace:")) {
+            return [];
+        }
+        return [
+            specifier.startsWith("workspace:@")
+                ? specifier.slice(10, specifier.lastIndexOf("@"))
+                : name,
+        ];
+    }));
+}
+export const completePackages = Effect.fn("Composition.completePackages")(function* ({ files, packageManifests, selectedManifests, governed, capture, requirements, ownedRequirements, registryItems, omittedDependencies = new Set(), }) {
+    const rootRequirements = yield* registryDependencies(registryItems);
+    const unique = new Map();
+    for (const requirement of requirements) {
+        const rootRequirement = requirement.target === "package.json"
+            ? rootRequirements.find((entry) => entry.name === requirement.name)
+            : undefined;
+        if (rootRequirement?.specifier &&
+            rootRequirement.specifier !== requirement.specifier) {
+            return yield* new InvalidComposition({
+                message: `Conflicting root dependency declarations: ${requirement.name}`,
+            });
+        }
+        const key = `${requirement.target}\0${requirement.section}\0${requirement.name}`;
+        const previous = unique.get(key);
+        if (previous && previous.specifier !== requirement.specifier) {
+            return yield* new InvalidComposition({
+                message: `Conflicting package requirements: ${requirement.target} ${requirement.section}.${requirement.name} (${previous.specifier}, ${requirement.specifier})`,
+            });
+        }
+        unique.set(key, requirement);
+    }
+    const outputManifests = new Map();
+    const reconcile = Effect.fn("Composition.reconcileManifest")(function* (target, file) {
+        const decoded = yield* Schema.decodeEffect(ManifestJson)(new TextDecoder().decode(file.content));
+        let manifest = { ...decoded };
+        for (const entry of ownedRequirements.filter((requirement) => requirement.target === target)) {
+            const section = manifest[entry.section];
+            if (section && Object.hasOwn(section, entry.name)) {
+                manifest[entry.section] = Object.fromEntries(Object.entries(section).filter(([name]) => name !== entry.name));
+            }
+        }
+        for (const requirement of unique.values()) {
+            if (requirement.target === target) {
+                manifest[requirement.section] = {
+                    ...manifest[requirement.section],
+                    [requirement.name]: requirement.specifier,
+                };
+            }
+        }
+        if (target === "package.json") {
+            manifest = applyRegistryDependencies(manifest, rootRequirements);
+        }
+        for (const section of [
+            "dependencies",
+            "devDependencies",
+            "optionalDependencies",
+            "peerDependencies",
+        ]) {
+            if (manifest[section]) {
+                manifest[section] = Object.fromEntries(Object.entries(manifest[section]).filter(([name]) => !omittedDependencies.has(name)));
+            }
+        }
+        outputManifests.set(target, {
+            ...file,
+            content: new TextEncoder().encode(`${yield* Schema.encodeEffect(ManifestJson)(manifest)}\n`),
+        });
+        return manifest;
+    });
+    const byName = new Map();
+    const manifests = new Map();
+    const packageRoots = packageManifests.map((file) => file.slice(0, -"package.json".length));
+    for (const file of packageManifests) {
+        const content = yield* capture(file);
+        const manifest = yield* Schema.decodeEffect(ManifestJson)(new TextDecoder().decode(content.content));
+        if (!manifest.name) {
+            return yield* new InvalidComposition({
+                message: `Missing package name: ${file}`,
+            });
+        }
+        if (byName.has(manifest.name)) {
+            return yield* new InvalidComposition({
+                message: `Duplicate package name: ${manifest.name}`,
+            });
+        }
+        byName.set(manifest.name, file);
+        manifests.set(file, manifest);
+    }
+    const pending = [];
+    for (const [target, file] of selectedManifests) {
+        const manifest = yield* reconcile(target, file);
+        if (manifest.name) {
+            byName.set(manifest.name, target);
+        }
+        manifests.set(target, manifest);
+        pending.push(...internalDependencies(manifest));
+    }
+    const selected = new Set();
+    const baseline = new Set();
+    const directories = new Set();
+    while (pending.length) {
+        const name = pending.pop();
+        if (name === undefined) {
+            break;
+        }
+        if (selected.has(name)) {
+            continue;
+        }
+        selected.add(name);
+        const manifestPath = byName.get(name);
+        if (!manifestPath) {
+            return yield* new InvalidComposition({
+                message: `Missing internal package: ${name}`,
+            });
+        }
+        if (!selectedManifests.has(manifestPath)) {
+            if (governed.has(manifestPath)) {
+                return yield* new InvalidComposition({
+                    message: `${name} requires its registry item to be selected`,
+                });
+            }
+            const directory = manifestPath.slice(0, -"package.json".length);
+            directories.add(directory.slice(0, -1));
+            manifests.set(manifestPath, yield* reconcile(manifestPath, yield* capture(manifestPath)));
+            for (const file of files.filter((candidate) => candidate.startsWith(directory) &&
+                !packageRoots.some((other) => other !== directory &&
+                    other.startsWith(directory) &&
+                    candidate.startsWith(other)) &&
+                eligiblePackageFile(candidate) &&
+                !governed.has(candidate))) {
+                yield* capture(file);
+                baseline.add(file);
+            }
+        }
+        const manifest = manifests.get(manifestPath);
+        if (!manifest) {
+            return yield* new InvalidComposition({
+                message: `Missing manifest for ${name}`,
+            });
+        }
+        pending.push(...internalDependencies(manifest));
+    }
+    for (const requirement of requirements) {
+        if (!outputManifests.has(requirement.target)) {
+            return yield* new InvalidComposition({
+                message: `Missing package requirement target: ${requirement.target}`,
+            });
+        }
+    }
+    return {
+        baseline,
+        directories: [...directories],
+        manifests: outputManifests,
+    };
+});

package/dist/process-group.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import type { ChildProcessSpawner } from "effect/unstable/process";
+export declare const groupExists: (pid: number) => Effect.Effect<boolean, import("effect/Cause").UnknownError, never>;
+export declare const confirmStopped: (handle: ChildProcessSpawner.ChildProcessHandle) => Effect.Effect<void, import("effect/Cause").UnknownError | import("effect/PlatformError").PlatformError | import("effect/Cause").TimeoutError, never>;
+//# sourceMappingURL=process-group.d.ts.map

package/dist/process-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-group.d.ts","sourceRoot":"","sources":["../src/process-group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAInE,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,uEAWnC,CAAC;AAEL,eAAO,MAAM,cAAc,GACzB,QAAQ,mBAAmB,CAAC,kBAAkB,yJASY,CAAC"}

package/dist/process-group.js

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+// The Node process service creates a POSIX process group. Leader exit alone
+// does not prove that lifecycle descendants have stopped writing.
+export const groupExists = (pid) => Effect.try(() => {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+            return false;
+        }
+        throw error;
+    }
+});
+export const confirmStopped = (handle) => Effect.gen(function* () {
+    if (yield* groupExists(handle.pid)) {
+        yield* handle.kill({ forceKillAfter: "100 millis" });
+        while (yield* groupExists(handle.pid)) {
+            yield* Effect.sleep("10 millis");
+        }
+    }
+}).pipe(Effect.interruptible, Effect.timeout("2 seconds"));

package/dist/reference-workspace-bindings.d.ts

@@ -0,0 +1,38 @@
+export declare const REFERENCE_WORKSPACE_NAME = "storefront-contentstack";
+export declare const REFERENCE_PROVIDERS: {
+    readonly auth: "workos";
+    readonly cms: "contentstack";
+    readonly commerce: "commercetools";
+    readonly search: "algolia";
+};
+export declare const referenceBindings: readonly [{
+    readonly alias: "@repo/search-provider";
+    readonly app: "web";
+    readonly provider: "search-algolia";
+}, {
+    readonly alias: "@repo/auth";
+    readonly app: "web";
+    readonly provider: "auth-workos";
+}, {
+    readonly alias: "@repo/cms";
+    readonly app: "web";
+    readonly provider: "cms-contentstack";
+}, {
+    readonly alias: "@repo/commerce-provider";
+    readonly app: "web";
+    readonly provider: "commerce-commercetools";
+}, {
+    readonly alias: "@repo/auth";
+    readonly app: "api";
+    readonly provider: "auth-workos";
+}, {
+    readonly alias: "@repo/commerce-provider";
+    readonly app: "api";
+    readonly provider: "commerce-commercetools";
+}, {
+    readonly alias: "@repo/auth";
+    readonly app: "admin";
+    readonly provider: "auth-workos";
+}];
+export declare function assertReferenceWorkspaceBindings(workspaceRoot: string): void;
+//# sourceMappingURL=reference-workspace-bindings.d.ts.map

package/dist/reference-workspace-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-workspace-bindings.d.ts","sourceRoot":"","sources":["../src/reference-workspace-bindings.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,wBAAwB,4BAA4B,CAAC;AAClE,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AACX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpB,CAAC;AAIX,wBAAgB,gCAAgC,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAgB5E"}

package/dist/reference-workspace-bindings.js

@@ -0,0 +1,41 @@
+import { readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { Schema } from "effect";
+import { ManifestJson } from "./packages.js";
+export const REFERENCE_WORKSPACE_NAME = "storefront-contentstack";
+export const REFERENCE_PROVIDERS = {
+    auth: "workos",
+    cms: "contentstack",
+    commerce: "commercetools",
+    search: "algolia",
+};
+export const referenceBindings = [
+    { alias: "@repo/search-provider", app: "web", provider: "search-algolia" },
+    { alias: "@repo/auth", app: "web", provider: "auth-workos" },
+    { alias: "@repo/cms", app: "web", provider: "cms-contentstack" },
+    {
+        alias: "@repo/commerce-provider",
+        app: "web",
+        provider: "commerce-commercetools",
+    },
+    { alias: "@repo/auth", app: "api", provider: "auth-workos" },
+    {
+        alias: "@repo/commerce-provider",
+        app: "api",
+        provider: "commerce-commercetools",
+    },
+    { alias: "@repo/auth", app: "admin", provider: "auth-workos" },
+];
+// Retained synchronous package export for test-runner configuration consumers.
+// CLI orchestration uses Effect FileSystem instead; this is not a second runtime.
+export function assertReferenceWorkspaceBindings(workspaceRoot) {
+    for (const { app, alias, provider } of referenceBindings) {
+        const appRoot = path.join(workspaceRoot, "apps", app);
+        const manifest = Schema.decodeSync(ManifestJson)(readFileSync(path.join(appRoot, "package.json"), "utf-8"));
+        if (manifest.dependencies?.[alias] !== `workspace:@repo/${provider}@*` ||
+            realpathSync(path.join(appRoot, "node_modules", alias)) !==
+                realpathSync(path.join(workspaceRoot, "packages", provider))) {
+            throw new Error(`${app}'s ${alias} must resolve to ${provider} inside ${REFERENCE_WORKSPACE_NAME}. Refresh and reinstall the reference workspace.`);
+        }
+    }
+}

package/dist/reference-workspace.d.ts

@@ -0,0 +1,6 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { ApplicationTaskFailed, InvalidComposition } from "./errors.ts";
+import { Workspaces } from "./workspaces.ts";
+export declare const testReferenceWorkspace: (sourceRoot: string) => Effect.Effect<undefined, ApplicationTaskFailed | import("./errors.ts").IncompatibleSelection | InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").DestinationNotEmpty | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | import("./errors.ts").MaterializationFailed | import("./errors.ts").EnvironmentInitializationFailed | import("./errors.ts").WorkspaceBusy | import("./errors.ts").WorkspaceLockAuthorizationRequired | import("./errors.ts").WorkspaceLockChanged | import("./errors.ts").WorkspaceConflict | import("./errors.ts").WorkspaceRecoveryRequired | import("./errors.ts").WorkspaceStateInvalid | import("./errors.ts").SnapshotUnavailable | import("./errors.ts").SnapshotFailed | import("./errors.ts").DependencyInstallationFailed | Schema.SchemaError | import("effect/PlatformError").PlatformError | import("./application-git.ts").ApplicationGitFailed, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | Workspaces>;
+//# sourceMappingURL=reference-workspace.d.ts.map

package/dist/reference-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-workspace.d.ts","sourceRoot":"","sources":["../src/reference-workspace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACnE,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAQxE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,eAAO,MAAM,sBAAsB,opCA6ElC,CAAC"}

package/dist/reference-workspace.js

@@ -0,0 +1,62 @@
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ApplicationTaskFailed, InvalidComposition } from "./errors.js";
+import { WorkspaceDefinition } from "./model.js";
+import { ManifestJson } from "./packages.js";
+import { referenceBindings, REFERENCE_PROVIDERS, REFERENCE_WORKSPACE_NAME, } from "./reference-workspace-bindings.js";
+import { Workspaces } from "./workspaces.js";
+export const testReferenceWorkspace = Effect.fn("WorkspaceTasks.testReference")(function* (sourceRoot) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const directory = path.join(sourceRoot, "workspaces", REFERENCE_WORKSPACE_NAME);
+    const definition = yield* fs
+        .readFileString(path.join(directory, "next-hydra.json"))
+        .pipe(Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(WorkspaceDefinition))));
+    if (["auth", "cms", "commerce", "search"].some((slot) => definition.providers[slot] !== REFERENCE_PROVIDERS[slot])) {
+        return yield* new InvalidComposition({
+            message: "Application tests require the reference storefront definition with WorkOS, Contentstack, commercetools and Algolia.",
+        });
+    }
+    const workspace = yield* (yield* Workspaces).named({
+        name: REFERENCE_WORKSPACE_NAME,
+        sourceRoot,
+    });
+    const result = yield* workspace.sync({});
+    if (result.dependencies !== "current") {
+        return yield* new InvalidComposition({
+            message: "Reference workspace dependencies are not current.",
+        });
+    }
+    for (const { app, alias, provider } of referenceBindings) {
+        const appRoot = path.join(directory, "apps", app);
+        const manifest = yield* fs
+            .readFileString(path.join(appRoot, "package.json"))
+            .pipe(Effect.flatMap(Schema.decodeEffect(ManifestJson)));
+        if (manifest.dependencies?.[alias] !== `workspace:@repo/${provider}@*` ||
+            (yield* fs.realPath(path.join(appRoot, "node_modules", alias))) !==
+                (yield* fs.realPath(path.join(directory, "packages", provider)))) {
+            return yield* new InvalidComposition({
+                message: `${app}'s ${alias} must resolve to ${provider} inside ${REFERENCE_WORKSPACE_NAME}. Refresh and reinstall it before testing.`,
+            });
+        }
+    }
+    yield* Console.log(`Application tests: ${REFERENCE_WORKSPACE_NAME}`);
+    const process = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const code = yield* process.exitCode(ChildProcess.make("pnpm", [
+        "exec",
+        "turbo",
+        "run",
+        "test",
+        "--filter=./apps/*",
+        "--only",
+        "--continue=always",
+    ], {
+        cwd: directory,
+        stderr: "inherit",
+        stdin: "inherit",
+        stdout: "inherit",
+    }));
+    if (code !== 0) {
+        return yield* new ApplicationTaskFailed({ code, directory });
+    }
+});