create-next-hydra 0.3.0 → 0.4.1

package/dist/composition/packages.js

@@ -1,55 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { z } from "zod";
-import { CompositionValidationError } from "./errors.js";
-import { formatZodError } from "./schema.js";
-const dependencyEntriesSchema = z.record(z.string());
-const packageJsonSchema = z
-    .object({
-    dependencies: dependencyEntriesSchema.optional(),
-    devDependencies: dependencyEntriesSchema.optional(),
-    optionalDependencies: dependencyEntriesSchema.optional(),
-})
-    .passthrough();
-function decodePackageJson(value, label) {
-    const result = packageJsonSchema.safeParse(value);
-    if (!result.success) {
-        throw new CompositionValidationError(`${label} is not a valid package.json file.`, formatZodError(result.error));
-    }
-    // Zod reconstructs objects in schema order, so return the validated input
-    // to preserve the manifest's existing key positions.
-    return value;
-}
-export function parsePackageJson(source, label) {
-    let value;
-    try {
-        value = JSON.parse(source);
-    }
-    catch (error) {
-        throw new CompositionValidationError(`${label} is not a valid package.json file.`, [error instanceof Error ? error.message : "JSON parsing failed"], { cause: error });
-    }
-    return decodePackageJson(value, label);
-}
-export async function readPackageJson(filePath, label = filePath) {
-    return parsePackageJson(await readFile(filePath, "utf-8"), label);
-}
-export function mergePackageRequirements(entries) {
-    const requirements = new Map();
-    const issues = [];
-    for (const requirement of entries) {
-        const key = `${requirement.cwd}\0${requirement.section}\0${requirement.name}`;
-        const existing = requirements.get(key);
-        if (existing && existing.specifier !== requirement.specifier) {
-            issues.push(`${requirement.cwd}/${requirement.section}.${requirement.name} is requested as both ${existing.specifier} and ${requirement.specifier}`);
-        }
-        else {
-            requirements.set(key, requirement);
-        }
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("Package requirements conflict.", 
-        // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-        [...new Set(issues)].sort((left, right) => left.localeCompare(right)));
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...requirements.values()].sort((left, right) => `${left.cwd}/${left.section}/${left.name}`.localeCompare(`${right.cwd}/${right.section}/${right.name}`));
-}

package/dist/composition/paths.d.ts

@@ -1,4 +0,0 @@
-export declare function resolveRegistryTarget(target: string): string;
-export declare function resolveWorkspacePath(value: string, label: string): string;
-export declare function isManagedApplicationSource(sourcePath: string, target: string | undefined): boolean;
-//# sourceMappingURL=paths.d.ts.map

package/dist/composition/paths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/composition/paths.ts"],"names":[],"mappings":"AA6BA,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAS5D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,OAAO,CAiBT"}

package/dist/composition/paths.js

@@ -1,47 +0,0 @@
-import path from "node:path";
-import { CompositionValidationError } from "./errors.js";
-const LEADING_CURRENT_DIRECTORY = /^\.\//;
-const REGISTRY_SOURCE_DIRECTORY = "registry";
-function normalizeRelativePath(value, label) {
-    if (value.includes("\\")) {
-        throw new CompositionValidationError("Unsafe composition path.", [
-            `${label} must use forward slashes: ${value}`,
-        ]);
-    }
-    const normalized = path.posix.normalize(value);
-    if (normalized === "." ||
-        normalized === ".." ||
-        normalized.startsWith("../") ||
-        path.posix.isAbsolute(normalized)) {
-        throw new CompositionValidationError("Unsafe composition path.", [
-            `${label} escapes or names the workspace root: ${value}`,
-        ]);
-    }
-    return normalized.replace(LEADING_CURRENT_DIRECTORY, "");
-}
-export function resolveRegistryTarget(target) {
-    if (!target.startsWith("~/")) {
-        throw new CompositionValidationError("Registry files require workspace-root targets.", [`files[].target must start with ~/: ${target}`]);
-    }
-    const relativeTarget = target.startsWith("~/") ? target.slice(2) : target;
-    return normalizeRelativePath(relativeTarget, "registry target");
-}
-export function resolveWorkspacePath(value, label) {
-    return normalizeRelativePath(value, label);
-}
-export function isManagedApplicationSource(sourcePath, target) {
-    if (!target?.startsWith("~/")) {
-        return false;
-    }
-    const normalized = path.posix
-        .normalize(sourcePath)
-        .replace(LEADING_CURRENT_DIRECTORY, "");
-    const marker = `/${REGISTRY_SOURCE_DIRECTORY}/`;
-    const sourceWithLeadingSlash = `/${normalized}`;
-    const markerIndex = sourceWithLeadingSlash.lastIndexOf(marker);
-    if (markerIndex === -1) {
-        return false;
-    }
-    return (sourceWithLeadingSlash.slice(markerIndex + marker.length) ===
-        target.slice(2));
-}

package/dist/composition/planner.d.ts

@@ -1,4 +0,0 @@
-import type { CompositionPlan, SourceRegistryCatalog, WorkspaceSelection } from "./types.js";
-export declare function planComposition(catalog: SourceRegistryCatalog, selection: WorkspaceSelection): CompositionPlan;
-export declare function selectionFromPreset(catalog: SourceRegistryCatalog, reference: string): WorkspaceSelection;
-//# sourceMappingURL=planner.d.ts.map

package/dist/composition/planner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/composition/planner.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAEV,eAAe,EAMf,qBAAqB,EAGrB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AA2YpB,wBAAgB,eAAe,CAC7B,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,kBAAkB,GAC5B,eAAe,CAmHjB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,MAAM,GAChB,kBAAkB,CAuBpB"}

package/dist/composition/planner.js

@@ -1,366 +0,0 @@
-import { resolveCatalogSelection, resolveRegistryItemGraph, } from "./catalog.js";
-import { CompositionValidationError } from "./errors.js";
-import { mergePackageRequirements } from "./packages.js";
-import { isManagedApplicationSource, resolveRegistryTarget, resolveWorkspacePath, } from "./paths.js";
-import { PROVIDER_ALIASES, PROVIDER_SLOTS } from "./types.js";
-function uniqueSorted(values) {
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-function itemTargets(catalog, itemName) {
-    const item = catalog.items.get(itemName);
-    if (!item) {
-        throw new CompositionValidationError("Missing registry item.", [
-            `${itemName} is not in the source registry`,
-        ]);
-    }
-    return uniqueSorted((item.files ?? []).map((file) => {
-        if (!file.target) {
-            throw new CompositionValidationError("Registry items require explicit targets.", [`${itemName}:${file.path} does not declare files[].target`]);
-        }
-        return resolveRegistryTarget(file.target);
-    }));
-}
-function itemManagedTargets(catalog, itemName) {
-    const item = catalog.items.get(itemName);
-    if (!item) {
-        throw new CompositionValidationError("Missing registry item.", [
-            `${itemName} is not in the source registry`,
-        ]);
-    }
-    return uniqueSorted((item.files ?? [])
-        .filter((file) => isManagedApplicationSource(file.path, file.target))
-        .map((file) => {
-        if (!file.target) {
-            throw new CompositionValidationError("Managed application files require explicit targets.", [`${itemName}:${file.path} does not declare files[].target`]);
-        }
-        return resolveRegistryTarget(file.target);
-    }));
-}
-function resolveProviders(catalog, selection) {
-    const providers = new Map();
-    const issues = [];
-    for (const slot of PROVIDER_SLOTS) {
-        const candidate = resolveCatalogSelection(catalog, selection.providers[slot]);
-        if (candidate.kind !== "provider" || candidate.slot !== slot) {
-            issues.push(`${selection.providers[slot]} is ${candidate.kind}${candidate.slot ? ` for ${candidate.slot}` : ""}, not a ${slot} provider`);
-            continue;
-        }
-        providers.set(slot, candidate);
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("Provider Slot cardinality is invalid.", issues);
-    }
-    return providers;
-}
-function resolveAddOns(catalog, references, providers) {
-    const selected = new Map();
-    const queue = references.map((reference) => resolveCatalogSelection(catalog, reference));
-    const selectedProviderIds = new Set(providers.map((provider) => provider.id));
-    const enqueueRequiredAddOns = (selection) => {
-        for (const requiredId of selection.compatibility.requires) {
-            if (selectedProviderIds.has(requiredId) || selected.has(requiredId)) {
-                continue;
-            }
-            const required = catalog.byId.get(requiredId);
-            if (required?.kind === "add-on") {
-                queue.push(required);
-            }
-        }
-    };
-    for (const provider of providers) {
-        enqueueRequiredAddOns(provider);
-    }
-    while (queue.length > 0) {
-        const candidate = queue.shift();
-        if (!candidate) {
-            continue;
-        }
-        if (candidate.kind !== "add-on") {
-            throw new CompositionValidationError("Invalid Add-on selection.", [
-                `${candidate.id} is ${candidate.kind}, not an add-on`,
-            ]);
-        }
-        if (selected.has(candidate.id)) {
-            continue;
-        }
-        selected.set(candidate.id, candidate);
-        enqueueRequiredAddOns(candidate);
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...selected.values()].sort((left, right) => left.id.localeCompare(right.id));
-}
-function validateCompatibility(selections) {
-    const selectedIds = new Set(selections.map((selection) => selection.id));
-    const issues = [];
-    for (const selection of selections) {
-        for (const requiredId of selection.compatibility.requires) {
-            if (!selectedIds.has(requiredId)) {
-                issues.push(`${selection.id} requires ${requiredId}`);
-            }
-        }
-        for (const conflictingId of selection.compatibility.conflicts) {
-            if (selectedIds.has(conflictingId)) {
-                issues.push(`${selection.id} conflicts with ${conflictingId}`);
-            }
-        }
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("The requested selections are incompatible.", uniqueSorted(issues));
-    }
-}
-const BASELINE_PROVIDER_DEPENDENCIES = [
-    { cwd: "apps/admin", section: "dependencies", slot: "auth" },
-    { cwd: "apps/api", section: "dependencies", slot: "auth" },
-    { cwd: "apps/cli", section: "dependencies", slot: "auth" },
-    { cwd: "apps/web", section: "dependencies", slot: "auth" },
-    { cwd: "packages/feature-flags", section: "dependencies", slot: "auth" },
-    { cwd: "tests/e2e", section: "devDependencies", slot: "auth" },
-    { cwd: "apps/cli", section: "dependencies", slot: "cms" },
-    { cwd: "apps/web", section: "dependencies", slot: "cms" },
-    { cwd: "apps/api", section: "dependencies", slot: "commerce" },
-    { cwd: "apps/cli", section: "dependencies", slot: "commerce" },
-    { cwd: "apps/web", section: "dependencies", slot: "commerce" },
-    { cwd: "tests/e2e", section: "devDependencies", slot: "commerce" },
-];
-function selectedProviderDependencies(selections) {
-    return [
-        ...BASELINE_PROVIDER_DEPENDENCIES,
-        ...selections.flatMap((selection) => selection.providerDependencies),
-    ];
-}
-function catalogProviderDependencies(catalog) {
-    return [
-        ...BASELINE_PROVIDER_DEPENDENCIES,
-        ...catalog.selections.flatMap((selection) => selection.providerDependencies),
-    ];
-}
-function resolveProviderRequirements(providers, dependencies) {
-    const packageRequirements = [];
-    const typeScriptPathAliases = new Map();
-    for (const dependency of dependencies) {
-        const provider = providers.get(dependency.slot);
-        if (!provider?.binding) {
-            throw new CompositionValidationError("Provider binding is missing.", [
-                `${dependency.slot} does not supply a Provider binding`,
-            ]);
-        }
-        const alias = PROVIDER_ALIASES[dependency.slot];
-        packageRequirements.push({
-            cwd: dependency.cwd,
-            name: alias,
-            section: dependency.section,
-            specifier: provider.binding.specifier,
-        });
-        if (provider.binding.sourcePath) {
-            typeScriptPathAliases.set(`${dependency.cwd}\0${alias}`, {
-                alias,
-                cwd: dependency.cwd,
-                sourcePath: resolveWorkspacePath(provider.binding.sourcePath, `${provider.id} Provider binding source path`),
-            });
-        }
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    const aliases = [...typeScriptPathAliases.values()].sort((left, right) => `${left.cwd}/${left.alias}`.localeCompare(`${right.cwd}/${right.alias}`));
-    return { packageRequirements, typeScriptPathAliases: aliases };
-}
-function catalogTypeScriptPathAliases(dependencies) {
-    const aliases = new Map();
-    for (const dependency of dependencies) {
-        const alias = PROVIDER_ALIASES[dependency.slot];
-        aliases.set(`${dependency.cwd}\0${alias}`, {
-            alias,
-            cwd: dependency.cwd,
-        });
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...aliases.values()].sort((left, right) => `${left.cwd}/${left.alias}`.localeCompare(`${right.cwd}/${right.alias}`));
-}
-function catalogPackageRequirementTargets(catalog, providerDependencies) {
-    const targets = new Map();
-    const add = (target) => {
-        targets.set(`${target.cwd}\0${target.section}\0${target.name}`, target);
-    };
-    for (const selection of catalog.selections) {
-        for (const { cwd, name, section } of selection.packages) {
-            add({ cwd, name, section });
-        }
-    }
-    for (const dependency of providerDependencies) {
-        add({
-            cwd: dependency.cwd,
-            name: PROVIDER_ALIASES[dependency.slot],
-            section: dependency.section,
-        });
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...targets.values()].sort((left, right) => `${left.cwd}/${left.section}/${left.name}`.localeCompare(`${right.cwd}/${right.section}/${right.name}`));
-}
-function resolvePnpmPatches(selections) {
-    const patches = new Map();
-    const issues = [];
-    for (const selection of selections) {
-        for (const patch of selection.pnpmPatches) {
-            const normalized = {
-                ...patch,
-                path: resolveWorkspacePath(patch.path, `${selection.id} pnpm patch path`),
-            };
-            const existing = patches.get(normalized.dependency);
-            if (existing && existing.path !== normalized.path) {
-                issues.push(`${normalized.dependency} is patched by both ${existing.path} and ${normalized.path}`);
-            }
-            else {
-                patches.set(normalized.dependency, normalized);
-            }
-        }
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("pnpm patches conflict.", issues);
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...patches.values()].sort((left, right) => left.dependency.localeCompare(right.dependency));
-}
-function catalogPnpmPatches(catalog) {
-    const patches = new Map();
-    for (const selection of catalog.selections) {
-        for (const patch of selection.pnpmPatches) {
-            const normalized = {
-                ...patch,
-                path: resolveWorkspacePath(patch.path, `${selection.id} pnpm patch path`),
-            };
-            if (!patches.has(normalized.dependency)) {
-                patches.set(normalized.dependency, normalized);
-            }
-        }
-    }
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return [...patches.values()].sort((left, right) => left.dependency.localeCompare(right.dependency));
-}
-function catalogVariableTargets(catalog) {
-    return uniqueSorted([...catalog.items.values()].flatMap((item) => item.files?.map((file) => {
-        if (!file.target) {
-            throw new CompositionValidationError("Registry items require explicit targets.", [`${item.name}:${file.path} does not declare files[].target`]);
-        }
-        return resolveRegistryTarget(file.target);
-    }) ?? []));
-}
-function validateMaterializationTargets(options) {
-    const claims = new Map();
-    const issues = [];
-    const claim = (target, owner) => {
-        const existing = claims.get(target);
-        if (existing && existing !== owner) {
-            issues.push(`${target} is claimed by both ${existing} and ${owner}`);
-            return;
-        }
-        claims.set(target, owner);
-    };
-    for (const item of options.registryItems) {
-        for (const target of itemTargets(options.catalog, item)) {
-            claim(target, `registry item ${item}`);
-        }
-    }
-    for (const asset of options.assets) {
-        claim(asset.target, `asset ${asset.source}`);
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("Materialization targets conflict.", uniqueSorted(issues));
-    }
-}
-export function planComposition(catalog, selection) {
-    const providers = resolveProviders(catalog, selection);
-    const providerSelections = PROVIDER_SLOTS.map((slot) => {
-        const provider = providers.get(slot);
-        if (!provider) {
-            throw new CompositionValidationError("Provider Slot cardinality is invalid.", [`${slot} requires exactly one provider`]);
-        }
-        return provider;
-    });
-    const addOns = resolveAddOns(catalog, selection.addOns, providerSelections);
-    const selections = [...providerSelections, ...addOns];
-    validateCompatibility(selections);
-    const providerDependencies = selectedProviderDependencies(selections);
-    const catalogDependencies = catalogProviderDependencies(catalog);
-    const providerRequirements = resolveProviderRequirements(providers, providerDependencies);
-    const packageRequirements = mergePackageRequirements([
-        ...selections.flatMap((selected) => selected.packages),
-        ...providerRequirements.packageRequirements,
-    ]);
-    const entryItems = uniqueSorted(selections.map((selected) => selected.itemName));
-    const registryItems = resolveRegistryItemGraph(catalog, entryItems);
-    const assets = selections
-        .flatMap((selected) => selected.assets.map((asset) => ({
-        source: resolveWorkspacePath(asset.source, `${selected.id} asset source`),
-        target: resolveWorkspacePath(asset.target, `${selected.id} asset target`),
-    })))
-        // eslint-disable-next-line unicorn/no-array-sort -- flatMap creates a fresh array.
-        .sort((left, right) => left.target.localeCompare(right.target));
-    const pnpmPatches = resolvePnpmPatches(selections);
-    const assetTargets = new Set(assets.map((asset) => asset.target));
-    const missingPatchAssets = pnpmPatches
-        .filter((patch) => !assetTargets.has(patch.path))
-        .map((patch) => `${patch.dependency} references ${patch.path}, which is not a selected asset target`);
-    if (missingPatchAssets.length > 0) {
-        throw new CompositionValidationError("pnpm patch files are missing.", missingPatchAssets);
-    }
-    validateMaterializationTargets({
-        assets,
-        catalog,
-        registryItems,
-    });
-    const managedTargets = uniqueSorted(registryItems.flatMap((item) => itemManagedTargets(catalog, item)));
-    const directlySelectedAddOnIds = new Set(selection.addOns.map((reference) => resolveCatalogSelection(catalog, reference).id));
-    const requiredAddOnIds = addOns
-        .filter((addOn) => !directlySelectedAddOnIds.has(addOn.id))
-        .map((addOn) => addOn.id);
-    return {
-        assets,
-        catalogManagedTargets: catalog.managedTargets,
-        catalogPackageRequirementTargets: catalogPackageRequirementTargets(catalog, catalogDependencies),
-        catalogPnpmPatches: catalogPnpmPatches(catalog),
-        catalogTypeScriptPathAliases: catalogTypeScriptPathAliases(catalogDependencies),
-        entryItems,
-        instructions: [
-            ...new Set(selections
-                .map((selected) => catalog.items.get(selected.itemName)?.docs)
-                .filter((value) => Boolean(value))),
-        ],
-        managedTargets,
-        packageRequirements,
-        pnpmPatches,
-        registryItems,
-        selection: {
-            ...selection,
-            addOns: uniqueSorted([...selection.addOns, ...requiredAddOnIds]),
-            providers: { ...selection.providers },
-        },
-        selections,
-        typeScriptPathAliases: providerRequirements.typeScriptPathAliases,
-        variableTargets: uniqueSorted([
-            ...catalogVariableTargets(catalog),
-            ...catalog.selections.flatMap((selected) => selected.assets.map((asset) => resolveWorkspacePath(asset.target, `${selected.id} asset target`))),
-        ]),
-    };
-}
-export function selectionFromPreset(catalog, reference) {
-    const preset = resolveCatalogSelection(catalog, reference);
-    if (preset.kind !== "preset" || !preset.selections?.providers) {
-        throw new CompositionValidationError("Invalid Preset selection.", [
-            `${reference} is not a complete Next Hydra preset`,
-        ]);
-    }
-    const { addOns, providers } = preset.selections;
-    if (!(providers.auth && providers.cms && providers.commerce)) {
-        throw new CompositionValidationError("Preset is incomplete.", [
-            `${preset.id} must select auth, cms, and commerce providers`,
-        ]);
-    }
-    return {
-        addOns,
-        providers: {
-            auth: providers.auth,
-            cms: providers.cms,
-            commerce: providers.commerce,
-        },
-    };
-}