@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/recipe/compile/shared.d.ts

@@ -0,0 +1,442 @@
+import { type FieldValue, type Operation, type PushPolicy } from "../ir/operations";
+import { type FieldDefinition, type ParamDefinition } from "../schema/recipe";
+/**
+ * Where a recipe's items land in the Sitecore content tree. Tenant-side
+ * config — recipes themselves are tenant-agnostic. The compiler emits
+ * deterministic Sitecore paths (`<templatesRoot>/<recipe.name>`, etc.)
+ * that the executor resolves to server-assigned itemIds at runtime.
+ */
+export interface CompileContext {
+    /**
+     * Legacy flat templates root, e.g. `/sitecore/templates/Project/<site>`.
+     * The component template, parameters template, and (when present)
+     * Component Folder template land directly under this when `section`
+     * is omitted. When `section` is set on a `ComponentTemplateRecipe`,
+     * the compiler instead nests under the configured `componentsRoot`
+     * (preferred) or — fallback — under `templatesRoot/<section>`.
+     *
+     * Required for back-compat with callers that haven't migrated to the
+     * site-folder layout.
+     */
+    templatesRoot: string;
+    /**
+     * Renderings root. With `section`, the rendering lands at
+     * `<renderingsRoot>/<section>/<Component>`. Without section, falls
+     * back to the legacy flat `<renderingsRoot>/<Component>`.
+     */
+    renderingsRoot: string;
+    /**
+     * Per-site Components bucket — `/sitecore/templates/Project/<site>/Components`.
+     * When set AND a `ComponentTemplateRecipe` carries a `section`, the
+     * compiler emits at `<componentsRoot>/<section>/<Component>` and
+     * companion paths (Component Folders / Presentation Parameters)
+     * also nest under the section. When unset, the compiler falls back
+     * to `templatesRoot` for back-compat with the flat layout.
+     *
+     * Optional today; will become the canonical input once the
+     * orchestrator's `buildRecipeRoots()` returns the new bucket-roots
+     * shape (see `plans/recipe-site-folder-layout.md`).
+     */
+    componentsRoot?: string;
+    /**
+     * Per-site Content Models bucket —
+     * `/sitecore/templates/Project/<site>/Content Models`. When set AND a
+     * `ContentTemplateRecipe` is being compiled, the template lands at
+     * `<contentModelsRoot>/<group>/<name>` (when the recipe carries
+     * `meta.tax.group`) or flat at `<contentModelsRoot>/<name>` otherwise.
+     * When unset, the compiler falls back to `templatesRoot`.
+     */
+    contentModelsRoot?: string;
+    /**
+     * Phase 4: required for `PartialDesignRecipe` compilation. Where the
+     * partial-design items land — typically
+     * `/sitecore/content/<site>/Presentation/Partial Designs`.
+     * Optional in the type so Phase 1 callers don't have to set it; the
+     * partial-design compiler errors with a clear message if absent.
+     */
+    partialDesignsRoot?: string;
+    /**
+     * Phase 4: required for `PageDesignRecipe` compilation. Where the
+     * page-design items land — typically
+     * `/sitecore/content/<site>/Presentation/Page Designs`.
+     *
+     * The page-design compiler also emits a SetField op writing
+     * `TemplatesMapping` on this root item itself. The executor resolves
+     * the root item's GUID via a pre-seeded `crossRecipeRefs` entry the
+     * orchestrator pipeline-step provides at runtime.
+     */
+    pageDesignsRoot?: string;
+    /**
+     * Phase 4: required for `ContentItemRecipe` compilation. Where shared
+     * content items land — typically `/sitecore/content/<tenant>/<site>/Data`
+     * or a sub-bucket for SXA sites. ContentItemRecipes encode `kind: "shared"`
+     * datasource targets referenced from partial / page design layouts.
+     */
+    contentItemsRoot?: string;
+    /**
+     * Phase 5: required for `SiteTemplateRecipe` compilation. Where SXA
+     * Site Template items land — typically `/sitecore/templates/Project/<brand>`
+     * or a sub-folder for module groupings. Site templates are reusable
+     * brand-shape definitions; `SiteRecipe` instances reference one via
+     * `siteTemplate` and the Sites API instantiates it.
+     */
+    siteTemplatesRoot?: string;
+    /**
+     * Site name — e.g. `solterra`. Drives deterministic refKeys for
+     * site-scoped folders (section folders, Component Folders subfolders,
+     * Presentation Parameters subfolders, Content Models group folders).
+     * When unset, folder-creation ops fall back to a `default` site name
+     * to keep refKeys stable; production callers should always set this.
+     */
+    site?: string;
+    /**
+     * SXA Headless variants root, e.g.
+     * `/sitecore/content/<siteCollection>/<site>/Presentation/Headless Variants`.
+     * Each component-template recipe's variants land at
+     * `<headlessVariantsRoot>/<section>/<Component>/<Variant>` and conform
+     * to the SXA `Variant Definition` template. The two grouping levels
+     * (section + per-component) use `HeadlessVariantsGrouping` and
+     * `HeadlessVariants` respectively.
+     *
+     * Required for any recipe that declares `variants`. The compiler
+     * throws INPUT_INVALID before emitting variant ops if it's missing —
+     * the legacy "variants nested under the rendering item" location no
+     * longer matches SXA Headless and is no longer supported.
+     */
+    headlessVariantsRoot?: string;
+    /**
+     * Enumerations root, e.g.
+     * `/sitecore/content/<siteCollection>/<site>/Settings/Enumerations`.
+     * Each `EnumerationRecipe` lands at `<enumerationsRoot>/<EnumName>`
+     * with one child item per value. Required for `EnumerationRecipe`
+     * compilation; required for `ComponentTemplateRecipe`/
+     * `ParametersTemplateRecipe` compilation when any field carries
+     * `sitecore.enumHandle`. Compiler throws INPUT_INVALID with a clear
+     * message when needed but missing.
+     */
+    enumerationsRoot?: string;
+    /**
+     * Cross-recipe signal populated by `compileRecipeSet` when two or more
+     * `ComponentTemplateRecipe`s in the set declare site-scoped datasource
+     * locations against the same `subfolder`. Membership flips per-recipe
+     * Data Folder template emission OFF (the coalescer emits a SHARED
+     * template instead) and changes the folder ITEM's `templateOf` to point
+     * at `sharedDataFolderTemplateId(site, subfolder)`.
+     *
+     * Optional. Standalone callers of `compileComponentTemplateRecipe`
+     * leave this unset — every site-scoped subfolder is treated as a
+     * singleton (per-recipe template owns the folder), preserving the
+     * pre-coalescer behaviour.
+     */
+    sharedSubfolders?: ReadonlySet<string>;
+    /**
+     * Cross-recipe map of section handles → `ComponentSectionRecipe`,
+     * populated by `compileRecipeSet` from every `component-section`
+     * recipe in the input. `compileComponentTemplateRecipe` uses this to
+     * resolve `recipe.section.handle` → section name (for path
+     * computation) and to validate the reference exists (else
+     * INPUT_INVALID).
+     *
+     * Optional. Standalone callers of `compileComponentTemplateRecipe`
+     * leave this unset; the per-recipe compiler then errors on any
+     * `recipe.section` reference, since there's no way to resolve it.
+     */
+    sectionsByHandle?: ReadonlyMap<string, import("../schema/recipe").ComponentSectionRecipe>;
+    /**
+     * Cross-recipe map of enumeration handles → `EnumerationRecipe`,
+     * populated by `compileRecipeSet` from every `enumeration` recipe in
+     * the input. Field compilers (`buildFieldOp` → `resolveFieldSource`)
+     * use this to resolve `sitecore.enumHandle` → the enum folder's
+     * tenant path, so Droplink Source values are emitted as content paths
+     * (which SXA Headless's rendering parameter dialog enumerates) rather
+     * than `{GUID}` references (which it doesn't honour for Droplink
+     * Source).
+     *
+     * Optional. Standalone callers leave it unset; the field compiler
+     * then errors on any `sitecore.enumHandle` reference, since there's
+     * no way to resolve the folder path.
+     */
+    enumsByHandle?: ReadonlyMap<string, import("../schema/recipe").EnumerationRecipe>;
+    /**
+     * SXA Available Renderings root, e.g.
+     * `/sitecore/content/<siteCollection>/<site>/Presentation/Available Renderings`.
+     * `compileRecipeSet` aggregates every component-template recipe by
+     * `recipe.section`, emits one `Available Renderings` item per
+     * section, and writes the section's renderings (as Sitecore-formatted
+     * itemIds) into the `Renderings` multilist field. The SXA editor
+     * reads this list when the user composes a page — without it, the
+     * editor shows the global rendering list instead of a curated
+     * per-section subset.
+     *
+     * Optional. When unset, compileRecipeSet skips the aggregation
+     * entirely. Component-template recipes without `section` are also
+     * skipped — there's no section to bucket them under.
+     */
+    availableRenderingsRoot?: string;
+}
+export declare const PARAMS_SECTION_NAME = "Parameters";
+export declare const DEFAULT_FIELDS_SECTION = "Content";
+export declare const COMPONENT_FOLDERS_BUCKET = "Component Folders";
+export declare const PRESENTATION_PARAMETERS_BUCKET = "Presentation Parameters";
+export declare const joinPath: (parent: string, name: string) => string;
+/** Site name for deterministic folder refKeys. */
+export declare const siteOf: (context: CompileContext) => string;
+/**
+ * Resolve a `sitecore.enumHandle` reference to the tenant content path
+ * the enumeration's folder lives at. Used by `resolveFieldSource` to
+ * emit Droplink Source values as content paths (the form SXA Headless's
+ * rendering parameter dialog accepts) rather than `{GUID}` references.
+ *
+ * Path shape:
+ *   - With `location.folder` set →
+ *     `<enumerationsRoot>/<folder>/<enum.name>`.
+ *   - Without `location.folder` → `<enumerationsRoot>/<enum.name>` (flat).
+ *
+ * Throws INPUT_INVALID when the enum handle isn't in the recipe set
+ * (author error: `sitecore.enumHandle` references something that
+ * doesn't exist), or when `enumerationsRoot` is unset on the context.
+ */
+export declare const resolveEnumFolderPath: (context: CompileContext, enumHandle: string, consumerHandle: string) => string;
+export declare function sharedField(fieldGuid: string, value: FieldValue["value"]): FieldValue;
+export declare function versionedField(fieldGuid: string, value: FieldValue["value"]): FieldValue;
+/**
+ * Resolve the parent path under which a `ComponentTemplateRecipe`'s
+ * template item lands.
+ *
+ *   - With section + componentsRoot → `<componentsRoot>/<section>` (new layout).
+ *   - With section only → `<templatesRoot>/<section>` (mid-migration fallback).
+ *   - Without section → `<templatesRoot>` (legacy flat layout).
+ */
+export declare const resolveComponentTemplateParent: (context: CompileContext, section: string | undefined) => string;
+/**
+ * Resolve the parent path for a Component Folder template — the
+ * `<Component> Folder` items emitted when a recipe declares
+ * `children:`. Always nested under
+ * `<sectionRoot>/Component Folders/`.
+ */
+export declare const resolveComponentFoldersBucketPath: (context: CompileContext, section: string) => string;
+/**
+ * Resolve the parent path for a Presentation Parameters template —
+ * `<sectionRoot>/Presentation Parameters/`. When the recipe lacks a
+ * section (legacy callers), parameters templates land directly under
+ * `templatesRoot` to match the old flat layout.
+ */
+export declare const resolvePresentationParametersBucketPath: (context: CompileContext, section: string | undefined) => string;
+/**
+ * Resolve the parent path for the rendering item.
+ *
+ *   - With section → `<renderingsRoot>/<section>/<Component>`.
+ *   - Without → legacy flat `<renderingsRoot>/<Component>`.
+ */
+export declare const resolveRenderingParent: (context: CompileContext, section: string | undefined) => string;
+/**
+ * Ensure a section folder (under `componentsRoot/<section>`) exists.
+ * Idempotent: emits a CreateOnly CreateItem op the first time a given
+ * (site, section) pair is seen and records the refKey in the
+ * `emittedFolders` set so subsequent calls are no-ops.
+ *
+ * Returns the section folder's refKey for downstream callers that want
+ * to nest items under it.
+ */
+export declare const ensureSectionFolder: (operations: Operation[], context: CompileContext, section: string, emittedFolders: Set<string>) => string;
+/**
+ * Ensure a "Component Folders" subfolder exists under the section
+ * folder. Idempotent.
+ */
+export declare const ensureComponentFoldersBucket: (operations: Operation[], context: CompileContext, section: string, emittedFolders: Set<string>) => string;
+/**
+ * Ensure a "Presentation Parameters" subfolder exists under the section
+ * folder. Idempotent.
+ */
+export declare const ensurePresentationParametersBucket: (operations: Operation[], context: CompileContext, section: string, emittedFolders: Set<string>) => string;
+/**
+ * Ensure a section subfolder under the renderings tree exists —
+ * `<renderingsRoot>/<section>/`. Mirrors the templates side; the
+ * rendering tree shape mirrors the template tree per the layout plan.
+ */
+export declare const ensureRenderingsSectionFolder: (operations: Operation[], context: CompileContext, section: string, emittedFolders: Set<string>) => string;
+/**
+ * Ensure a Content Models group folder exists. Returns the refKey for
+ * downstream `CreateItem.parent` references. Idempotent across
+ * repeated calls within one recipe-set compile.
+ */
+export declare const ensureContentModelsGroupFolder: (operations: Operation[], context: CompileContext, group: string, emittedFolders: Set<string>) => string | undefined;
+/**
+ * Per-site SXA-style enumeration template trio. Three templates with
+ * distinct roles — emitted as siblings under the site's
+ * `Presentation/` templates folder:
+ *
+ *   Enumerations Folder        → folder layers in the enum content tree
+ *                                (root, per-folder grouping items)
+ *     └── __Standard Values    Insert Options: Enumeration + Enumerations Folder
+ *
+ *   Enumeration                → per-enum container items
+ *                                (`Color Scheme`, `Heading Size`, etc.)
+ *     └── __Standard Values    Insert Options: Enumeration Value
+ *
+ *   Enumeration Value          → leaf value items
+ *                                (`primary`, `accent`, `lg`, `shooting-star`)
+ *     └── Enumeration (section)
+ *           └── Value (Single-Line Text, shared)
+ *
+ * All three inherit from Standard Template only and stamp the
+ * `keyboard_key_e.png` icon so the SXA editor recognises enum items
+ * as enumeration entries (not folders) without per-item icon overrides.
+ *
+ * The `Value` field on `Enumeration Value` carries each value item's
+ * actual enumeration string (`"primary"`, `"shooting-star"`, etc.) —
+ * the canonical SXA "picked item's Value field" payload that Droplink
+ * consumers (XM Cloud Pages, JSS variants, custom Edge resolvers) read.
+ *
+ * Insert Options are wired so authors can right-click without picking
+ * templates from a long list:
+ *   - Inside an `Enumerations Folder` → Insert: `Enumeration` (typical)
+ *     or `Enumerations Folder` (nesting, e.g. `Theme/Color`)
+ *   - Inside an `Enumeration` → Insert: `Enumeration Value` only
+ *   - Inside an `Enumeration Value` → no Insert Options (leaves)
+ *
+ * Idempotent across the recipe set — the templates are emitted on
+ * first call and re-uses are no-ops via the shared `emittedFolders`
+ * set. Returns the deterministic refKeys for all three templates +
+ * the `Value` field so callers can wire `templateOf` and `Value` field
+ * writes correctly.
+ */
+export interface EnumerationTemplateRefs {
+    folderTemplateRefKey: string;
+    /** Per-enum container template (Color Scheme, Heading Size, …). */
+    enumerationTemplateRefKey: string;
+    /**
+     * RefKey of the `Value` Template Field under the *Enumeration*
+     * template's inner `Enumeration` section. Carries each per-enum
+     * container's canonical default (driven by `EnumerationRecipe.default`).
+     * Distinct from `valueFieldRefKey` (which is on the Enumeration Value
+     * template, for leaf items).
+     */
+    containerValueFieldRefKey: string;
+    /** Leaf value template (primary, accent, lg, …). Carries the `Value` field. */
+    valueTemplateRefKey: string;
+    /**
+     * RefKey of the `Value` Template Field under the Enumeration Value
+     * template. Callers writing the field on individual value items pair
+     * this with `fieldName: "Value"` so the executor's tenant-side
+     * resolver can locate the field by name (recipe-derived field GUIDs
+     * don't match the Sitecore-assigned ones).
+     */
+    valueFieldRefKey: string;
+}
+export declare const ensureEnumerationTemplates: (operations: Operation[], context: CompileContext, site: string, emittedFolders: Set<string>) => EnumerationTemplateRefs;
+export interface DatasourceTemplateInput {
+    handle: string;
+    name: string;
+    displayName: string;
+    fields: FieldDefinition[];
+    insertOptions?: string[];
+    /**
+     * Optional override for the template's parent path. When set, the
+     * template lands at `<parentPath>/<name>` and `parent` resolves via
+     * `ref-path`. When omitted, falls back to `context.templatesRoot`
+     * for back-compat with the legacy flat layout.
+     */
+    parentPath?: string;
+    /**
+     * Optional override for the template's parent — when the parent has
+     * already been emitted as a CreateItem op in this set (e.g. a section
+     * folder), passing the refKey here lets the planner resolve via the
+     * captured-itemId map without needing a path-based lookup. Mutually
+     * exclusive with `parentPath`'s refKey-as-string semantics.
+     */
+    parentRefKey?: string;
+    /**
+     * Extra template GUIDs to append to the synthesised
+     * `SetBaseTemplates` op (in addition to the implicit Standard
+     * Template). Used by `compileComponentTemplateRecipe` to wire in the
+     * SXA Foundation bases (`SXA_COMPONENT_BASE_TEMPLATES`) so the
+     * resulting template is recognised as an SXA Headless component;
+     * datasource-only callers (`compileContentTemplateRecipe`) leave it
+     * unset so content templates stay shape-pure.
+     */
+    additionalBaseTemplates?: readonly string[];
+}
+export declare function emitDatasourceTemplate(operations: Operation[], recipe: DatasourceTemplateInput, context: CompileContext, icon: string, policy: PushPolicy): void;
+export interface BuildFieldOpInput {
+    recipeHandle: string;
+    fieldRefKey: string;
+    fieldPath: string;
+    parentRefKey: string;
+    labelPrefix: string;
+    field: FieldDefinition | ParamDefinition;
+    zeroBasedIndex: number;
+    policy: PushPolicy;
+    /**
+     * Site name the recipe set is being compiled under. Threaded through to
+     * `resolveFieldSource` so the emitted `ref-source-fields` value carries
+     * the site — the executor's resolver needs it to derive `templateId(site,
+     * handle)` for handle references in `sourceTypes`.
+     */
+    site: string;
+    /**
+     * Compile context — used by `resolveFieldSource` to look up
+     * `sitecore.enumHandle` references against `enumsByHandle` and emit
+     * the enum's tenant content path as the Droplink Source value.
+     * Standalone callers can omit it, but any field with
+     * `sitecore.enumHandle` will then throw INPUT_INVALID since the path
+     * can't be resolved.
+     */
+    context?: CompileContext;
+}
+/**
+ * Build the CreateItem op for a single field definition.
+ *
+ * Always returns exactly one op — the field-definition item itself.
+ * Backing storage for enum-shaped fields is decided by the field's
+ * `sitecore.type` / `sitecore.enumHandle` and resolved into the
+ * `Source` field via `resolveFieldSource`:
+ *   - `sitecore.type: "droplist"` + inline `values: [...]` → Source is
+ *     a pipe-separated literal; Sitecore enumerates the string directly,
+ *     no value items needed.
+ *   - `sitecore.enumHandle: "<handle>"` (Droplink default) → Source is
+ *     the EnumerationRecipe's folder path on the tenant; the picker
+ *     enumerates that path's children at editor time. The values live
+ *     under the `EnumerationRecipe`'s folder item, emitted by
+ *     `compileEnumerationRecipe`.
+ *
+ * Inline Droplink (`shape: "enum"` + inline `values` + no `enumHandle`
+ * + no `sitecore.type` override) is rejected by `resolveFieldSource`
+ * with INPUT_INVALID — it never reliably worked in SXA Headless's
+ * rendering parameters dialog (the picker couldn't enumerate the
+ * per-field folder), so authors must commit to one of the two
+ * supported shapes.
+ */
+export declare function buildFieldOp(input: BuildFieldOpInput): Operation[];
+/**
+ * Build the field-default entries for a template's `__Standard Values`
+ * item. Each entry carries the field's recipe-derived `fieldId` AND
+ * `fieldName` — Sitecore resolves recipe-created field GUIDs by name
+ * against the SV item's template (the recipe-derived id won't match the
+ * tenant's server-assigned field-definition id; the name lookup is what
+ * actually writes the value).
+ *
+ * Reference-shape defaults (link / image / treelist, plus
+ * non-enum-backed droplink) are skipped silently — those need encoded
+ * GUIDs or structured payloads that the simple `default: "string"`
+ * recipe surface can't express. Authors who need defaults for those
+ * can layer them in via a `ContentItemRecipe` that targets the SV
+ * path explicitly.
+ *
+ * Enum-shaped fields branch on the resolved Type:
+ *   - **Type=Droplist** (override): default is the raw string. Droplist
+ *     reads its options from a pipe-separated Source; SV default is a
+ *     name match against that list.
+ *   - **Type=Droplink + `sitecore.enumHandle`** (the canonical shared
+ *     enum shape): default is a `ref-recipe` GUID reference to the
+ *     value item under `enumerationFolderId(site, enumHandle)`.
+ *   - **Type=Droplink without `sitecore.enumHandle`** (inline Droplink):
+ *     unsupported — `resolveFieldSource` rejects it upstream and this
+ *     function throws defensively if it ever reaches here.
+ *
+ * If the declared default isn't actually one of the enum's values, the
+ * derived GUID won't exist on the tenant and the SV write fails at
+ * apply time — author error, not silently masked here.
+ */
+export declare function buildStandardValuesFieldEntries(site: string, handle: string, fields: ReadonlyArray<FieldDefinition | ParamDefinition>, fieldIdResolver?: (site: string, handle: string, fieldName: string) => string): FieldValue[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/recipe/compile/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/recipe/compile/shared.ts"],"names":[],"mappings":"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"}