@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/recipe/validate.d.ts

@@ -0,0 +1,103 @@
+import type { Recipe } from "./schema/recipe";
+/**
+ * Cross-recipe validation: walks every handle reference in a recipe set
+ * and verifies it resolves to an extant recipe of the right kind.
+ *
+ * `compileRecipe` operates on one recipe at a time and can't see the
+ * surrounding set; this module is the seam that catches dangling or
+ * mistyped references before the planner / executor swallows them.
+ *
+ * Reference inventory checked:
+ *
+ *   ComponentTemplateRecipe / ContentTemplateRecipe
+ *     fields[*].sitecore.sourceTypes[*]   → any template-bearing recipe
+ *     params[*].sitecore.sourceTypes[*]   → any template-bearing recipe
+ *     insertOptions[*]                    → any template-bearing recipe
+ *
+ *   ContentItemRecipe
+ *     templateType                        → any template-bearing recipe
+ *     fields[*].link-internal.ref         → any recipe
+ *     fields[*].reference.refs[*]         → any recipe
+ *
+ *   PartialDesignRecipe
+ *     layout.placeholders[*][*].componentHandle           → ComponentTemplateRecipe
+ *     layout.placeholders[*][*].datasourceRef.handle      → ContentItemRecipe
+ *
+ *   PageDesignRecipe
+ *     appliesTo[*]                        → ContentTemplateRecipe (page templates)
+ *     partials[*]                         → PartialDesignRecipe
+ *     layout.placeholders[*][*].componentHandle           → ComponentTemplateRecipe
+ *     layout.placeholders[*][*].datasourceRef.handle      → ContentItemRecipe
+ *
+ * Cycle detection covers `insertOptions` chains
+ * (`ComponentTemplate.insertOptions → ContentTemplate.insertOptions → …`)
+ * — the only place the current schema permits transitive recipe-to-recipe
+ * references that could loop. Partial-to-partial cycles aren't possible
+ * today (`PartialDesignRecipe` doesn't reference other partials); when
+ * sub-partial composition lands (Phase 5+), extend the DFS below.
+ */
+export type RecipeKind = Recipe["kind"];
+/** A handle reference that doesn't resolve, or resolves to the wrong kind. */
+export interface UnresolvedHandle {
+    /** Handle of the recipe that contains the bad reference. */
+    fromRecipe: string;
+    /** Dotted path inside the recipe — `layout.placeholders./header.0.componentHandle`. */
+    fromField: string;
+    /** The reference value that didn't resolve. */
+    handle: string;
+    /** Which recipe kinds would be valid resolutions. */
+    expectedKinds: readonly RecipeKind[];
+    /** The kind that was found (or undefined if no recipe with that handle exists). */
+    actualKind: RecipeKind | undefined;
+}
+/** A handle that appears more than once in the recipe set. */
+export interface DuplicateHandle {
+    handle: string;
+    count: number;
+}
+/** A cyclic chain of `insertOptions` references. */
+export interface CyclicReference {
+    /** First handle in the cycle. */
+    startHandle: string;
+    /** Ordered handles that form the cycle (last entry = startHandle, closing the loop). */
+    cycle: readonly string[];
+}
+/**
+ * A field-shape constraint that Zod can't enforce. Today this is the
+ * `SiteRecipe` collectionId XOR collectionName presence check — the
+ * Zod schema can't carry a `.refine()` because `RecipeSchema` is a
+ * discriminated union, and discriminated unions reject `ZodEffects`
+ * members. Cross-field constraints land here instead.
+ */
+export interface FieldShapeError {
+    /** Handle of the recipe with the bad shape. */
+    fromRecipe: string;
+    /** Dotted path to the field(s) involved. */
+    fromField: string;
+    /** Operator-readable explanation. */
+    message: string;
+}
+export interface ValidationResult {
+    unresolvedHandles: UnresolvedHandle[];
+    duplicateHandles: DuplicateHandle[];
+    cycles: CyclicReference[];
+    fieldShapeErrors: FieldShapeError[];
+}
+export declare const isValid: (result: ValidationResult) => boolean;
+/**
+ * Render a `ValidationResult` as a multi-line, human-readable error
+ * report. Use `validateRecipeSetOrThrow` if you just want exceptions.
+ */
+export declare function formatValidationErrors(result: ValidationResult): string;
+/**
+ * Validate cross-recipe references in a recipe set. Returns a result
+ * with all detected problems — caller decides whether to throw, log,
+ * or surface them in CLI output.
+ */
+export declare function validateRecipeSet(recipes: readonly Recipe[]): ValidationResult;
+/**
+ * Convenience: validate and throw on any error. Use in pipelines that
+ * should hard-stop before compilation when the recipe set is malformed.
+ */
+export declare function validateRecipeSetOrThrow(recipes: readonly Recipe[]): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/recipe/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/recipe/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AAqBxC,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,aAAa,EAAE,SAAS,UAAU,EAAE,CAAC;IACrC,mFAAmF;IACnF,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;CACpC;AAED,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,oDAAoD;AACpD,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,wFAAwF;IACxF,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACrC;AAED,eAAO,MAAM,OAAO,GAAI,QAAQ,gBAAgB,KAAG,OAIb,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAqBvE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,gBAAgB,CAyQ9E;AAyDD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAQzE"}

package/dist/recipe/validate.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValid = void 0;
+exports.formatValidationErrors = formatValidationErrors;
+exports.validateRecipeSet = validateRecipeSet;
+exports.validateRecipeSetOrThrow = validateRecipeSetOrThrow;
+const errors_1 = require("../shared/errors");
+const TEMPLATE_KINDS = ["component-template", "content-template"];
+const COMPONENT_TEMPLATE_KINDS = ["component-template"];
+const CONTENT_TEMPLATE_KINDS = ["content-template"];
+const CONTENT_ITEM_KINDS = ["content-item"];
+const PARAMETERS_TEMPLATE_KINDS = ["parameters-template"];
+const SECTION_DEFINITION_KINDS = ["section-definition"];
+const PARTIAL_DESIGN_KINDS = ["partial-design"];
+const PAGE_DESIGN_KINDS = ["page-design"];
+const SITE_TEMPLATE_KINDS = ["site-template"];
+const ANY_KINDS = [
+    "component-template",
+    "content-template",
+    "content-item",
+    "parameters-template",
+    "section-definition",
+    "partial-design",
+    "page-design",
+];
+const isValid = (result) => result.unresolvedHandles.length === 0 &&
+    result.duplicateHandles.length === 0 &&
+    result.cycles.length === 0 &&
+    result.fieldShapeErrors.length === 0;
+exports.isValid = isValid;
+/**
+ * Render a `ValidationResult` as a multi-line, human-readable error
+ * report. Use `validateRecipeSetOrThrow` if you just want exceptions.
+ */
+function formatValidationErrors(result) {
+    const lines = [];
+    for (const dup of result.duplicateHandles) {
+        lines.push(`Duplicate handle '${dup.handle}' (appears ${dup.count} times in the recipe set).`);
+    }
+    for (const cycle of result.cycles) {
+        lines.push(`Cyclic insertOptions chain: ${cycle.cycle.join(" → ")}.`);
+    }
+    for (const err of result.unresolvedHandles) {
+        const found = err.actualKind === undefined
+            ? "no recipe with that handle in the set"
+            : `found a ${err.actualKind} recipe`;
+        lines.push(`${err.fromRecipe} → ${err.fromField}: '${err.handle}' is invalid (${found}; expected one of: ${err.expectedKinds.join(", ")}).`);
+    }
+    for (const err of result.fieldShapeErrors) {
+        lines.push(`${err.fromRecipe} → ${err.fromField}: ${err.message}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Validate cross-recipe references in a recipe set. Returns a result
+ * with all detected problems — caller decides whether to throw, log,
+ * or surface them in CLI output.
+ */
+function validateRecipeSet(recipes) {
+    const index = new Map();
+    const counts = new Map();
+    for (const recipe of recipes) {
+        counts.set(recipe.handle, (counts.get(recipe.handle) ?? 0) + 1);
+        if (!index.has(recipe.handle)) {
+            index.set(recipe.handle, recipe);
+        }
+    }
+    const duplicateHandles = [];
+    for (const [handle, count] of counts) {
+        if (count > 1)
+            duplicateHandles.push({ handle, count });
+    }
+    const unresolved = [];
+    const fieldShapeErrors = [];
+    const checkRef = (fromRecipe, fromField, handle, expectedKinds) => {
+        const target = index.get(handle);
+        if (target === undefined) {
+            unresolved.push({
+                fromRecipe,
+                fromField,
+                handle,
+                expectedKinds,
+                actualKind: undefined,
+            });
+            return;
+        }
+        if (!expectedKinds.includes(target.kind)) {
+            unresolved.push({
+                fromRecipe,
+                fromField,
+                handle,
+                expectedKinds,
+                actualKind: target.kind,
+            });
+        }
+    };
+    for (const recipe of recipes) {
+        switch (recipe.kind) {
+            case "component-template":
+                recipe.fields.forEach((field, idx) => {
+                    field.sitecore?.sourceTypes?.forEach((handle, sIdx) => {
+                        checkRef(recipe.handle, `fields.${idx}.sitecore.sourceTypes.${sIdx}`, handle, TEMPLATE_KINDS);
+                    });
+                });
+                recipe.params.forEach((param, idx) => {
+                    param.sitecore?.sourceTypes?.forEach((handle, sIdx) => {
+                        checkRef(recipe.handle, `params.${idx}.sitecore.sourceTypes.${sIdx}`, handle, TEMPLATE_KINDS);
+                    });
+                });
+                recipe.insertOptions?.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `insertOptions.${idx}`, handle, TEMPLATE_KINDS);
+                });
+                if (recipe.datasource?.template) {
+                    checkRef(recipe.handle, "datasource.template.handle", recipe.datasource.template.handle, CONTENT_TEMPLATE_KINDS);
+                }
+                if (recipe.parameters) {
+                    checkRef(recipe.handle, "parameters.handle", recipe.parameters.handle, PARAMETERS_TEMPLATE_KINDS);
+                }
+                recipe.children?.allowedHandles.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `children.allowedHandles.${idx}`, handle, TEMPLATE_KINDS);
+                });
+                recipe.availableIn?.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `availableIn.${idx}`, handle, SECTION_DEFINITION_KINDS);
+                });
+                break;
+            case "parameters-template":
+                recipe.params.forEach((param, idx) => {
+                    param.sitecore?.sourceTypes?.forEach((handle, sIdx) => {
+                        checkRef(recipe.handle, `params.${idx}.sitecore.sourceTypes.${sIdx}`, handle, TEMPLATE_KINDS);
+                    });
+                });
+                break;
+            case "section-definition":
+                // Section definitions don't carry cross-recipe references — they
+                // ARE the resolution target for `availableIn`.
+                break;
+            case "content-template":
+                recipe.fields.forEach((field, idx) => {
+                    field.sitecore?.sourceTypes?.forEach((handle, sIdx) => {
+                        checkRef(recipe.handle, `fields.${idx}.sitecore.sourceTypes.${sIdx}`, handle, TEMPLATE_KINDS);
+                    });
+                });
+                recipe.insertOptions?.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `insertOptions.${idx}`, handle, TEMPLATE_KINDS);
+                });
+                break;
+            case "content-item":
+                checkRef(recipe.handle, "templateType", recipe.templateType, TEMPLATE_KINDS);
+                for (const [fieldName, value] of Object.entries(recipe.fields)) {
+                    if (value.shape === "link-internal") {
+                        checkRef(recipe.handle, `fields.${fieldName}.ref`, value.ref, ANY_KINDS);
+                    }
+                    else if (value.shape === "reference") {
+                        value.refs.forEach((handle, idx) => {
+                            checkRef(recipe.handle, `fields.${fieldName}.refs.${idx}`, handle, ANY_KINDS);
+                        });
+                    }
+                }
+                break;
+            case "partial-design":
+                for (const [phKey, placements] of Object.entries(recipe.layout.placeholders)) {
+                    placements.forEach((placement, idx) => {
+                        checkRef(recipe.handle, `layout.placeholders.${phKey}.${idx}.componentHandle`, placement.componentHandle, COMPONENT_TEMPLATE_KINDS);
+                        if (placement.datasourceRef?.kind === "shared") {
+                            checkRef(recipe.handle, `layout.placeholders.${phKey}.${idx}.datasourceRef.handle`, placement.datasourceRef.handle, CONTENT_ITEM_KINDS);
+                        }
+                    });
+                }
+                break;
+            case "page-design":
+                recipe.appliesTo.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `appliesTo.${idx}`, handle, CONTENT_TEMPLATE_KINDS);
+                });
+                recipe.partials.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `partials.${idx}`, handle, PARTIAL_DESIGN_KINDS);
+                });
+                if (recipe.layout) {
+                    for (const [phKey, placements] of Object.entries(recipe.layout.placeholders)) {
+                        placements.forEach((placement, idx) => {
+                            checkRef(recipe.handle, `layout.placeholders.${phKey}.${idx}.componentHandle`, placement.componentHandle, COMPONENT_TEMPLATE_KINDS);
+                            if (placement.datasourceRef?.kind === "shared") {
+                                checkRef(recipe.handle, `layout.placeholders.${phKey}.${idx}.datasourceRef.handle`, placement.datasourceRef.handle, CONTENT_ITEM_KINDS);
+                            }
+                        });
+                    }
+                }
+                break;
+            case "site-template":
+                recipe.pageTemplates.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `pageTemplates.${idx}`, handle, CONTENT_TEMPLATE_KINDS);
+                });
+                recipe.pageDesigns.forEach((handle, idx) => {
+                    checkRef(recipe.handle, `pageDesigns.${idx}`, handle, PAGE_DESIGN_KINDS);
+                });
+                if (recipe.insertOptionsMatrix) {
+                    for (const [parentHandle, allowedChildren] of Object.entries(recipe.insertOptionsMatrix)) {
+                        // The KEY is itself a page-template handle. Validate it too —
+                        // a typo in the key would silently never apply at apply time.
+                        checkRef(recipe.handle, `insertOptionsMatrix.${parentHandle}`, parentHandle, CONTENT_TEMPLATE_KINDS);
+                        allowedChildren.forEach((childHandle, idx) => {
+                            checkRef(recipe.handle, `insertOptionsMatrix.${parentHandle}.${idx}`, childHandle, CONTENT_TEMPLATE_KINDS);
+                        });
+                    }
+                }
+                if (recipe.templatesToDesigns) {
+                    for (const [templateHandle, designHandle] of Object.entries(recipe.templatesToDesigns)) {
+                        checkRef(recipe.handle, `templatesToDesigns.${templateHandle} (key)`, templateHandle, CONTENT_TEMPLATE_KINDS);
+                        checkRef(recipe.handle, `templatesToDesigns.${templateHandle}`, designHandle, PAGE_DESIGN_KINDS);
+                    }
+                }
+                break;
+            case "site":
+                checkRef(recipe.handle, "siteTemplate", recipe.siteTemplate, SITE_TEMPLATE_KINDS);
+                if (recipe.initialHome !== undefined) {
+                    // PageRecipe doesn't exist yet — accept any kind. When
+                    // PageRecipe lands, narrow this to PAGE_RECIPE_KINDS.
+                    checkRef(recipe.handle, "initialHome", recipe.initialHome, ANY_KINDS);
+                }
+                // Cross-field shape: SiteRecipe must specify exactly one of
+                // collectionId or collectionName. The Zod schema can't enforce
+                // it (discriminated union members can't carry refines), so the
+                // constraint lives here.
+                if (recipe.collectionId && recipe.collectionName) {
+                    fieldShapeErrors.push({
+                        fromRecipe: recipe.handle,
+                        fromField: "collectionId, collectionName",
+                        message: "collectionId and collectionName are mutually exclusive — provide one, not both",
+                    });
+                }
+                if (!recipe.collectionId && !recipe.collectionName) {
+                    fieldShapeErrors.push({
+                        fromRecipe: recipe.handle,
+                        fromField: "collectionId, collectionName",
+                        message: "either collectionId (existing) or collectionName (new) must be provided",
+                    });
+                }
+                break;
+        }
+    }
+    const cycles = detectInsertOptionsCycles(index, recipes);
+    return { unresolvedHandles: unresolved, duplicateHandles, cycles, fieldShapeErrors };
+}
+/**
+ * DFS over `insertOptions` edges. Each unique cycle is reported once,
+ * normalized to start at the alphabetically-smallest handle so re-runs
+ * over the same input produce stable output regardless of iteration
+ * order.
+ */
+function detectInsertOptionsCycles(index, recipes) {
+    const cycles = new Map();
+    const visited = new Set();
+    const stack = [];
+    const inStack = new Set();
+    const dfs = (handle) => {
+        if (inStack.has(handle)) {
+            const cycleStart = stack.indexOf(handle);
+            const ring = stack.slice(cycleStart);
+            const minIdx = ring.reduce((acc, h, i) => (h < ring[acc] ? i : acc), 0);
+            const normalized = [...ring.slice(minIdx), ...ring.slice(0, minIdx), ring[minIdx]];
+            const key = normalized.join("→");
+            if (!cycles.has(key)) {
+                cycles.set(key, { startHandle: normalized[0], cycle: normalized });
+            }
+            return;
+        }
+        if (visited.has(handle))
+            return;
+        visited.add(handle);
+        inStack.add(handle);
+        stack.push(handle);
+        const recipe = index.get(handle);
+        if (recipe !== undefined &&
+            (recipe.kind === "component-template" || recipe.kind === "content-template") &&
+            recipe.insertOptions !== undefined) {
+            for (const child of recipe.insertOptions) {
+                dfs(child);
+            }
+        }
+        stack.pop();
+        inStack.delete(handle);
+    };
+    for (const recipe of recipes) {
+        if (!visited.has(recipe.handle))
+            dfs(recipe.handle);
+    }
+    return [...cycles.values()];
+}
+/**
+ * Convenience: validate and throw on any error. Use in pipelines that
+ * should hard-stop before compilation when the recipe set is malformed.
+ */
+function validateRecipeSetOrThrow(recipes) {
+    const result = validateRecipeSet(recipes);
+    if (!(0, exports.isValid)(result)) {
+        throw (0, errors_1.createCliError)(`Recipe set validation failed:\n${formatValidationErrors(result)}`, "INPUT_INVALID");
+    }
+}

package/dist/serialization/commands.d.ts

@@ -0,0 +1,48 @@
+import { ItemData, ItemMetadata } from "./types";
+import { FilesystemTreeSpec } from "./tree-spec";
+import { ItemComparisonResult } from "./compare";
+export type ItemCommandType = "create" | "update" | "move" | "rename" | "recycle";
+export type UpdateCommandData = {
+    command: "CHANGE_TEMPLATE";
+    data: string;
+} | {
+    command: "UPDATE";
+    data: {
+        fieldId: string;
+        language?: string;
+        version?: number;
+        value: string;
+        blobId?: string | null;
+    };
+} | {
+    command: "RESET_FIELD";
+    data: {
+        fieldId: string;
+        language?: string;
+        version?: number;
+    };
+} | {
+    command: "REMOVE_VERSION";
+    data: {
+        language: string;
+        version: number;
+    };
+} | {
+    command: "ADD_VERSION";
+    data: {
+        language: string;
+        version: number;
+    };
+};
+export type ItemCommand = {
+    type: ItemCommandType;
+    source: ItemMetadata;
+    destination?: ItemMetadata;
+    sourceData?: ItemData;
+    updateCommands?: UpdateCommandData[];
+};
+export declare const buildCommandsForSubtree: (subtree: FilesystemTreeSpec, sourceItems: ItemMetadata[], destinationItems: ItemMetadata[], applyAllowedPushOperations: boolean) => ItemCommand[];
+export declare const buildUpdateCommandData: (comparison: ItemComparisonResult, push: boolean) => UpdateCommandData[];
+export declare const enrichUpdateCommands: (commands: ItemCommand[], sourceData: Map<string, ItemData>, destinationData: Map<string, ItemData>, push: boolean) => void;
+export declare const enrichCreateCommands: (commands: ItemCommand[], sourceData: Map<string, ItemData>) => void;
+//# sourceMappingURL=commands.d.ts.map

package/dist/serialization/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/serialization/commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAyB,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAgB,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElF,MAAM,MAAM,iBAAiB,GACzB;IAAE,OAAO,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC5C;IACE,OAAO,EAAE,QAAQ,CAAC;IAClB,IAAI,EAAE;QACJ,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACxB,CAAC;CACH,GACD;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC1F;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC1E;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAE5E,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,UAAU,CAAC,EAAE,QAAQ,CAAC;IACtB,cAAc,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACtC,CAAC;AAYF,eAAO,MAAM,uBAAuB,GAClC,SAAS,kBAAkB,EAC3B,aAAa,YAAY,EAAE,EAC3B,kBAAkB,YAAY,EAAE,EAChC,4BAA4B,OAAO,KAClC,WAAW,EA2Cb,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,YAAY,oBAAoB,EAChC,MAAM,OAAO,KACZ,iBAAiB,EA6FnB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,WAAW,EAAE,EACvB,YAAY,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EACjC,iBAAiB,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EACtC,MAAM,OAAO,KACZ,IAgBF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,WAAW,EAAE,EACvB,YAAY,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,KAChC,IAOF,CAAC"}

package/dist/serialization/commands.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichCreateCommands = exports.enrichUpdateCommands = exports.buildUpdateCommandData = exports.buildCommandsForSubtree = void 0;
+const tree_spec_1 = require("./tree-spec");
+const compare_1 = require("./compare");
+const restrictedTemplateId = "AB86861A-6030-46C5-B394-E8F99E8B87DB";
+const restrictedFieldId = "8CDC337E-A112-42FB-BBB4-4143751E123F";
+const fieldResetAllowed = (item, fieldId) => {
+    return (item.templateId.toUpperCase() !== restrictedTemplateId ||
+        fieldId.toUpperCase() !== restrictedFieldId);
+};
+const buildCommandsForSubtree = (subtree, sourceItems, destinationItems, applyAllowedPushOperations) => {
+    const commands = [];
+    const sourceMap = new Map(sourceItems.map((item) => [item.id, item]));
+    const destinationMap = new Map(destinationItems.map((item) => [item.id, item]));
+    for (const item of sourceItems) {
+        const dest = destinationMap.get(item.id);
+        const allowed = applyAllowedPushOperations
+            ? subtree.getAllowedPushOperationsForItem(item.path)
+            : tree_spec_1.AllowedPushOperations.CreateUpdateAndDelete;
+        if (!dest) {
+            commands.push({ type: "create", source: item });
+            continue;
+        }
+        if (allowed !== tree_spec_1.AllowedPushOperations.CreateOnly) {
+            if (item.parentId !== dest.parentId) {
+                commands.push({ type: "move", source: item, destination: dest });
+            }
+            if (item.path.itemName !== dest.path.itemName) {
+                commands.push({ type: "rename", source: item, destination: dest });
+            }
+            if (!item.dataSignature || !dest.dataSignature || item.dataSignature !== dest.dataSignature) {
+                commands.push({ type: "update", source: item, destination: dest });
+            }
+        }
+    }
+    for (const dest of destinationItems) {
+        if (sourceMap.has(dest.id)) {
+            continue;
+        }
+        const allowed = applyAllowedPushOperations
+            ? subtree.getAllowedPushOperationsForItem(dest.path)
+            : tree_spec_1.AllowedPushOperations.CreateUpdateAndDelete;
+        if (allowed === tree_spec_1.AllowedPushOperations.CreateUpdateAndDelete) {
+            commands.push({ type: "recycle", source: dest });
+        }
+    }
+    return orderCommands(commands);
+};
+exports.buildCommandsForSubtree = buildCommandsForSubtree;
+const buildUpdateCommandData = (comparison, push) => {
+    const updates = [];
+    if (comparison.isTemplateChanged) {
+        updates.push({ command: "CHANGE_TEMPLATE", data: comparison.leftItem.templateId });
+    }
+    for (const version of comparison.changedVersions) {
+        if (version.leftVersion && !version.rightVersion) {
+            updates.push({
+                command: "ADD_VERSION",
+                data: { language: version.leftVersion.language, version: version.leftVersion.version },
+            });
+        }
+        if (version.rightVersion && !version.leftVersion) {
+            updates.push({
+                command: "REMOVE_VERSION",
+                data: { language: version.rightVersion.language, version: version.rightVersion.version },
+            });
+            continue;
+        }
+        for (const field of version.changedFields) {
+            if (field.leftField) {
+                updates.push({
+                    command: "UPDATE",
+                    data: {
+                        fieldId: field.leftField.fieldId,
+                        language: version.language,
+                        version: version.versionNumber,
+                        value: field.leftField.value ?? "",
+                        blobId: field.leftField.blobId ?? null,
+                    },
+                });
+            }
+            else if (field.rightField &&
+                (!push || fieldResetAllowed(comparison.rightItem, field.rightField.fieldId))) {
+                updates.push({
+                    command: "RESET_FIELD",
+                    data: {
+                        fieldId: field.rightField.fieldId,
+                        language: version.language,
+                        version: version.versionNumber,
+                    },
+                });
+            }
+        }
+    }
+    for (const language of comparison.changedUnversionedFields) {
+        for (const field of language.changedFields) {
+            if (field.leftField) {
+                updates.push({
+                    command: "UPDATE",
+                    data: {
+                        fieldId: field.leftField.fieldId,
+                        language: language.language.language,
+                        value: field.leftField.value ?? "",
+                        blobId: field.leftField.blobId ?? null,
+                    },
+                });
+            }
+            else if (field.rightField) {
+                updates.push({
+                    command: "RESET_FIELD",
+                    data: {
+                        fieldId: field.rightField.fieldId,
+                        language: language.language.language,
+                    },
+                });
+            }
+        }
+    }
+    for (const field of comparison.changedSharedFields) {
+        if (field.leftField) {
+            updates.push({
+                command: "UPDATE",
+                data: {
+                    fieldId: field.leftField.fieldId,
+                    value: field.leftField.value ?? "",
+                    blobId: field.leftField.blobId ?? null,
+                },
+            });
+        }
+        else if (field.rightField) {
+            updates.push({
+                command: "RESET_FIELD",
+                data: { fieldId: field.rightField.fieldId },
+            });
+        }
+    }
+    return updates;
+};
+exports.buildUpdateCommandData = buildUpdateCommandData;
+const enrichUpdateCommands = (commands, sourceData, destinationData, push) => {
+    for (const command of commands) {
+        if (command.type !== "update") {
+            continue;
+        }
+        const source = sourceData.get(command.source.id);
+        const dest = destinationData.get(command.source.id);
+        if (!source || !dest) {
+            continue;
+        }
+        const comparison = (0, compare_1.compareItems)(source, dest);
+        command.sourceData = source;
+        command.updateCommands = (0, exports.buildUpdateCommandData)(comparison, push);
+    }
+};
+exports.enrichUpdateCommands = enrichUpdateCommands;
+const enrichCreateCommands = (commands, sourceData) => {
+    for (const command of commands) {
+        if (command.type !== "create") {
+            continue;
+        }
+        command.sourceData = sourceData.get(command.source.id);
+    }
+};
+exports.enrichCreateCommands = enrichCreateCommands;
+const orderCommands = (commands) => {
+    const depth = (item) => item.path.count;
+    const createUpdateMoveRename = commands.filter((cmd) => cmd.type !== "recycle");
+    const recycle = commands.filter((cmd) => cmd.type === "recycle");
+    createUpdateMoveRename.sort((a, b) => depth(a.source) - depth(b.source));
+    recycle.sort((a, b) => depth(b.source) - depth(a.source));
+    const standardValues = createUpdateMoveRename.filter((command) => command.type === "create" && command.source.path.toPathString().includes("__Standard Values"));
+    const rest = createUpdateMoveRename.filter((command) => !standardValues.includes(command));
+    return [...rest, ...standardValues, ...recycle];
+};

package/dist/serialization/compare.d.ts

@@ -0,0 +1,29 @@
+import { ItemData, ItemFieldValue, ItemLanguage, ItemVersion } from "./types";
+export type FieldComparisonResult = {
+    leftField: ItemFieldValue | null;
+    rightField: ItemFieldValue | null;
+};
+export type ItemLanguageComparisonResult = {
+    language: ItemLanguage;
+    changedFields: FieldComparisonResult[];
+};
+export type ItemVersionComparisonResult = {
+    leftVersion: ItemVersion | null;
+    rightVersion: ItemVersion | null;
+    changedFields: FieldComparisonResult[];
+    versionNumber: number;
+    language: string;
+};
+export type ItemComparisonResult = {
+    leftItem: ItemData;
+    rightItem: ItemData;
+    isRenamed: boolean;
+    isMoved: boolean;
+    isTemplateChanged: boolean;
+    isBranchChanged: boolean;
+    changedSharedFields: FieldComparisonResult[];
+    changedUnversionedFields: ItemLanguageComparisonResult[];
+    changedVersions: ItemVersionComparisonResult[];
+};
+export declare const compareItems: (left: ItemData, right: ItemData) => ItemComparisonResult;
+//# sourceMappingURL=compare.d.ts.map

package/dist/serialization/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../src/serialization/compare.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE9E,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,cAAc,GAAG,IAAI,CAAC;IACjC,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,YAAY,CAAC;IACvB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,QAAQ,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,mBAAmB,EAAE,qBAAqB,EAAE,CAAC;IAC7C,wBAAwB,EAAE,4BAA4B,EAAE,CAAC;IACzD,eAAe,EAAE,2BAA2B,EAAE,CAAC;CAChD,CAAC;AAkJF,eAAO,MAAM,YAAY,GAAI,MAAM,QAAQ,EAAE,OAAO,QAAQ,KAAG,oBAY9D,CAAC"}