@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/recipe/compile/component-section.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSectionRecipe = void 0;
+exports.compileComponentSectionRecipe = compileComponentSectionRecipe;
+const guids_1 = require("../guids");
+const operations_1 = require("../ir/operations");
+const errors_1 = require("../../shared/errors");
+const sitecore_templates_1 = require("../ir/sitecore-templates");
+const recipe_1 = require("../schema/recipe");
+const shared_1 = require("./shared");
+/**
+ * Compile a `ComponentSectionRecipe` to an Operation IR.
+ *
+ * Owns the three SECTION-LEVEL organisational items (one each per
+ * `(site, section.name)`):
+ *
+ *   1. Templates section folder        — `<componentsRoot>/<name>/`
+ *   4. Renderings-tree section folder  — `<renderingsRoot>/<name>/`
+ *   5. Headless Variants section       — `<headlessVariantsRoot>/<name>/`
+ *
+ * Each carries the recipe's `displayName`, `icon`, and `sortOrder`
+ * fields so the SXA editor's tree shows the section with the author's
+ * intent. `compileRecipeSet` MUST process section recipes BEFORE
+ * component recipes — the per-section sentinels seeded into
+ * `emittedFolders` here make subsequent `ensureSectionFolder` /
+ * `ensureRenderingsSectionFolder` calls from component recipes
+ * no-op-with-the-section-already-existing.
+ *
+ * The two SUBORDINATE buckets (#2 Component Folders, #3 Presentation
+ * Parameters) are NOT emitted here — they're emitted lazily by
+ * `ensureComponentFoldersBucket` / `ensurePresentationParametersBucket`
+ * when a component recipe in the section actually needs them. They live
+ * under the section folder so they inherit positional context but get
+ * the default `FOLDER_ICON` (no per-bucket rich fields by design).
+ *
+ * The Available Renderings item (#6) is emitted by the cross-recipe
+ * aggregate `buildAvailableRenderingsAggregate` in `compile.ts`; it
+ * reads sections via the same `sectionsByHandle` map and applies the
+ * section recipe's `displayName` to the toolbox label.
+ */
+function compileComponentSectionRecipe(input, context, emittedFolders = new Set()) {
+    const recipe = recipe_1.ComponentSectionRecipeSchema.parse(input);
+    const operations = [];
+    const site = (0, shared_1.siteOf)(context);
+    const icon = recipe.icon ?? sitecore_templates_1.FOLDER_ICON;
+    const displayName = recipe.displayName ?? recipe.name;
+    const richFields = () => {
+        const fields = [
+            (0, shared_1.sharedField)(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: icon }),
+            (0, shared_1.versionedField)(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: displayName }),
+        ];
+        if (recipe.sortOrder !== undefined) {
+            fields.push((0, shared_1.sharedField)(sitecore_templates_1.SYSTEM_FIELDS.SORT_ORDER, { kind: "number", value: recipe.sortOrder }));
+        }
+        return fields;
+    };
+    // 1. Templates section folder. Lives under `componentsRoot` (Phase 2
+    //    layout) when set, otherwise under `templatesRoot` (legacy flat
+    //    fallback). Sentinel matches `ensureSectionFolder`'s key so
+    //    subsequent component recipes see it as already-emitted.
+    const templatesParent = context.componentsRoot ?? context.templatesRoot;
+    const templatesSectionRefKey = (0, guids_1.sectionFolderId)(site, recipe.name);
+    if (!emittedFolders.has(templatesSectionRefKey)) {
+        emittedFolders.add(templatesSectionRefKey);
+        operations.push({
+            op: "CreateItem",
+            policy: "CreateOnly",
+            label: `section-folder:${site}:${recipe.name}`,
+            id: templatesSectionRefKey,
+            path: (0, shared_1.joinPath)(templatesParent, recipe.name),
+            parent: { kind: "ref-path", value: templatesParent },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FOLDER,
+            name: recipe.name,
+            fields: richFields(),
+        });
+    }
+    // 4. Renderings-tree section folder. Mirrors the templates side; the
+    //    rendering tree shape mirrors the template tree per the layout
+    //    plan. Uses `RENDERING_FOLDER` template (verified against live
+    //    tenant); sentinel matches `ensureRenderingsSectionFolder`.
+    const renderingsSectionRefKey = (0, guids_1.renderingsSectionFolderId)(site, recipe.name);
+    if (!emittedFolders.has(renderingsSectionRefKey)) {
+        emittedFolders.add(renderingsSectionRefKey);
+        operations.push({
+            op: "CreateItem",
+            policy: "CreateOnly",
+            label: `renderings-section-folder:${site}:${recipe.name}`,
+            id: renderingsSectionRefKey,
+            path: (0, shared_1.joinPath)(context.renderingsRoot, recipe.name),
+            parent: { kind: "ref-path", value: context.renderingsRoot },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.RENDERING_FOLDER,
+            name: recipe.name,
+            fields: richFields(),
+        });
+    }
+    // 5. Headless Variants section grouping. Only emitted when the tenant
+    //    is configured for variants (`headlessVariantsRoot` set); the
+    //    sentinel matches the inline emission in
+    //    `component-template.ts:emitVariants` so component recipes that
+    //    declare variants don't double-emit.
+    if (context.headlessVariantsRoot) {
+        const variantsSectionRefKey = (0, guids_1.headlessVariantsSectionFolderId)(site, recipe.name);
+        if (!emittedFolders.has(variantsSectionRefKey)) {
+            emittedFolders.add(variantsSectionRefKey);
+            operations.push({
+                op: "CreateItem",
+                policy: "CreateOnly",
+                label: `headless-variants-section-folder:${site}:${recipe.name}`,
+                id: variantsSectionRefKey,
+                path: (0, shared_1.joinPath)(context.headlessVariantsRoot, recipe.name),
+                parent: { kind: "ref-path", value: context.headlessVariantsRoot },
+                templateOf: sitecore_templates_1.SITECORE_TEMPLATES.HEADLESS_VARIANTS_GROUPING,
+                name: recipe.name,
+                fields: richFields(),
+            });
+        }
+    }
+    return operations_1.OperationIrSchema.parse({
+        schemaVersion: "1",
+        recipeHandle: recipe.handle,
+        operations,
+    });
+}
+/**
+ * Look up a `ComponentSectionRecipe` by handle. Throws INPUT_INVALID
+ * with a helpful hint when a component references a section handle no
+ * `ComponentSectionRecipe` in the set provides — this is the
+ * cross-recipe validation that closes the implicit-fallback gap the
+ * old `section: string` field had.
+ *
+ * `consumerHandle` is the recipe doing the lookup (used in the error
+ * message so authors can locate the source of the bad reference).
+ */
+const resolveSectionRecipe = (consumerHandle, sectionHandle, sectionsByHandle) => {
+    const section = sectionsByHandle?.get(sectionHandle);
+    if (!section) {
+        throw (0, errors_1.createCliError)(`Recipe '${consumerHandle}' references section.handle='${sectionHandle}' but no ComponentSectionRecipe with that handle is in the set.`, "INPUT_INVALID", {
+            hint: "Add a `ComponentSectionRecipe` (kind: 'component-section') with the matching handle to the recipe set, or change the consumer's `section.handle` to point at an existing one.",
+        });
+    }
+    return section;
+};
+exports.resolveSectionRecipe = resolveSectionRecipe;

package/dist/recipe/compile/component-template.d.ts

@@ -0,0 +1,34 @@
+import { type OperationIr } from "../ir/operations";
+import { type ComponentTemplateRecipe } from "../schema/recipe";
+import { type CompileContext } from "./shared";
+/**
+ * Compile a `ComponentTemplateRecipe` to an Operation IR.
+ *
+ * Pure: same recipe + same context → identical IR forever. The Authoring
+ * API server-assigns itemIds on `createItem`, so the IR carries Sitecore
+ * `path` fields for lookups + recipe-internal `refKey` GUIDs (uuidv5)
+ * which the executor uses as the key into a per-run captured-itemId map.
+ *
+ * Layout (per `plans/recipe-site-folder-layout.md`):
+ *
+ *   With `section: "ui"`:
+ *     - Section folder (CreateOnly) at `<componentsRoot>/ui`
+ *     - Template at `<componentsRoot>/ui/<Component>`
+ *     - When recipe declares `children:`, a Component Folder template at
+ *       `<componentsRoot>/ui/Component Folders/<Component> Folder`
+ *     - Inline `params:` (or `parameters: { handle }`) → Parameters
+ *       template at `<componentsRoot>/ui/Presentation Parameters/<name>`
+ *     - Renderings-side section folder (CreateOnly) at
+ *       `<renderingsRoot>/ui`, then rendering at
+ *       `<renderingsRoot>/ui/<Component>`
+ *     - For each handle in `availableIn`, an `AppendToMultiList` op
+ *       against the section definition's Available Renderings field
+ *
+ *   Without `section` (legacy back-compat):
+ *     - Flat layout — template at `<templatesRoot>/<Component>`,
+ *       parameters at `<templatesRoot>/<Component> Parameters`,
+ *       rendering at `<renderingsRoot>/<Component>`. No section folder
+ *       creation, no Component Folder generation.
+ */
+export declare function compileComponentTemplateRecipe(input: ComponentTemplateRecipe, context: CompileContext, emittedFolders?: Set<string>): OperationIr;
+//# sourceMappingURL=component-template.d.ts.map

package/dist/recipe/compile/component-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-template.d.ts","sourceRoot":"","sources":["../../../src/recipe/compile/component-template.ts"],"names":[],"mappings":"AAkBA,OAAO,EAKL,KAAK,WAAW,EAMjB,MAAM,kBAAkB,CAAC;AAc1B,OAAO,EAAE,KAAK,uBAAuB,EAAiC,MAAM,kBAAkB,CAAC;AAE/F,OAAO,EAiBL,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAkClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE,cAAc,EACvB,cAAc,GAAE,GAAG,CAAC,MAAM,CAAa,GACtC,WAAW,CAyFb"}