@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/serialization/tasks/users.d.ts

@@ -0,0 +1,5 @@
+import { readRootConfiguration, SerializationModuleConfiguration } from "../../config";
+import { Logger } from "../../shared/logger";
+export declare const syncUsersPull: (root: ReturnType<typeof readRootConfiguration>, module: SerializationModuleConfiguration, environmentName: string, logger: Logger) => Promise<void>;
+export declare const syncUsersPush: (root: ReturnType<typeof readRootConfiguration>, module: SerializationModuleConfiguration, environmentName: string, logger: Logger) => Promise<void>;
+//# sourceMappingURL=users.d.ts.map

package/dist/serialization/tasks/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/serialization/tasks/users.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;AACnF,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAmCzC,eAAO,MAAM,aAAa,GACxB,MAAM,UAAU,CAAC,OAAO,qBAAqB,CAAC,EAC9C,QAAQ,gCAAgC,EACxC,iBAAiB,MAAM,EACvB,QAAQ,MAAM,KACb,OAAO,CAAC,IAAI,CA8Bd,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,MAAM,UAAU,CAAC,OAAO,qBAAqB,CAAC,EAC9C,QAAQ,gCAAgC,EACxC,iBAAiB,MAAM,EACvB,QAAQ,MAAM,KACb,OAAO,CAAC,IAAI,CAyCd,CAAC"}

package/dist/serialization/tasks/users.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncUsersPush = exports.syncUsersPull = void 0;
+const sitecore_api_1 = require("../sitecore-api");
+const filesystem_store_1 = require("../filesystem-store");
+const shared_1 = require("./shared");
+const roles_1 = require("./roles");
+const profilePropsEqual = (left, right) => {
+    const serialize = (props) => [...props]
+        .map((prop) => `${prop.name}:${prop.content}:${prop.contentType}:${prop.isCustomProperty}`)
+        .sort();
+    const leftSerialized = serialize(left);
+    const rightSerialized = serialize(right);
+    if (leftSerialized.length !== rightSerialized.length) {
+        return false;
+    }
+    return leftSerialized.every((value, idx) => value === rightSerialized[idx]);
+};
+const usersEqual = (left, right) => left.userName.toLowerCase() === right.userName.toLowerCase() &&
+    (left.email ?? "") === (right.email ?? "") &&
+    (left.comment ?? "") === (right.comment ?? "") &&
+    left.isApproved === right.isApproved &&
+    (0, roles_1.rolesEqual)(left.roles, right.roles) &&
+    profilePropsEqual(left.profileProperties, right.profileProperties);
+const syncUsersPull = async (root, module, environmentName, logger) => {
+    if (module.users.length === 0) {
+        return;
+    }
+    const apiTimeoutMs = (0, shared_1.resolveApiTimeoutMs)(root);
+    const predicates = module.users.map((user) => ({ domain: user.domain, pattern: user.pattern }));
+    const sourceUsers = await (0, sitecore_api_1.fetchUsers)(root.environments[environmentName], predicates, {
+        timeoutMs: apiTimeoutMs,
+    });
+    const destUsers = await (0, filesystem_store_1.readUsersFromFilesystem)(root, module);
+    const destMap = new Map(destUsers.map((user) => [user.userName.toLowerCase(), user]));
+    for (const user of sourceUsers) {
+        const existing = destMap.get(user.userName.toLowerCase());
+        if (!existing || !usersEqual(existing, user)) {
+            await (0, filesystem_store_1.writeUserToFilesystem)(root, module, user);
+        }
+    }
+    if (root.serialization.removeOrphansForUsers) {
+        const sourceNames = new Set(sourceUsers.map((user) => user.userName.toLowerCase()));
+        for (const dest of destUsers) {
+            if (!sourceNames.has(dest.userName.toLowerCase())) {
+                await (0, filesystem_store_1.removeUserFromFilesystem)(dest.serializedItemId);
+            }
+        }
+    }
+    logger.info(`[users] Synced ${sourceUsers.length} users`, "green");
+};
+exports.syncUsersPull = syncUsersPull;
+const syncUsersPush = async (root, module, environmentName, logger) => {
+    if (module.users.length === 0) {
+        return;
+    }
+    const apiTimeoutMs = (0, shared_1.resolveApiTimeoutMs)(root);
+    const predicates = module.users.map((user) => ({ domain: user.domain, pattern: user.pattern }));
+    const sourceUsers = await (0, filesystem_store_1.readUsersFromFilesystem)(root, module);
+    const destinationUsers = await (0, sitecore_api_1.fetchUsers)(root.environments[environmentName], predicates, {
+        timeoutMs: apiTimeoutMs,
+    });
+    const destMap = new Map(destinationUsers.map((user) => [user.userName.toLowerCase(), user]));
+    const commands = [];
+    for (const user of sourceUsers) {
+        const dest = destMap.get(user.userName.toLowerCase());
+        if (!dest) {
+            commands.push({ userData: user, userCommandType: "ADD" });
+            continue;
+        }
+        if (!usersEqual(user, dest)) {
+            commands.push({ userData: user, userCommandType: "UPDATE" });
+        }
+    }
+    if (root.serialization.removeOrphansForUsers) {
+        const sourceNames = new Set(sourceUsers.map((user) => user.userName.toLowerCase()));
+        for (const user of destinationUsers) {
+            if (!sourceNames.has(user.userName.toLowerCase())) {
+                commands.push({ userData: user, userCommandType: "REMOVE" });
+            }
+        }
+    }
+    if (commands.length > 0) {
+        await (0, sitecore_api_1.pushUserCommands)(root.environments[environmentName], commands, {
+            timeoutMs: apiTimeoutMs,
+        });
+    }
+    logger.info(`[users] Synced ${commands.length} user changes`, "green");
+};
+exports.syncUsersPush = syncUsersPush;

package/dist/serialization/tasks/validate.d.ts

@@ -0,0 +1,5 @@
+import type { CommonOptions } from "./types";
+export declare const runValidate: (options: CommonOptions & {
+    fix?: boolean;
+}) => Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/serialization/tasks/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/serialization/tasks/validate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,WAAW,GAAU,SAAS,aAAa,GAAG;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,KAAG,OAAO,CAAC,IAAI,CAgD1F,CAAC"}

package/dist/serialization/tasks/validate.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runValidate = void 0;
+const filesystem_store_1 = require("../filesystem-store");
+const shared_1 = require("./shared");
+const runValidate = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { modules } = await (0, shared_1.loadConfigAndModules)(options);
+    const subtrees = modules.flatMap((module) => module.items.includes);
+    const { metadata } = await (0, filesystem_store_1.loadFilesystemItems)(subtrees);
+    const seenIds = new Set();
+    let hasErrors = false;
+    let duplicateCount = 0;
+    for (const item of metadata) {
+        const id = item.id.toLowerCase();
+        if (seenIds.has(id)) {
+            logger.error(`Duplicate serialized item id detected: ${item.id}`);
+            hasErrors = true;
+            duplicateCount += 1;
+            if (!options.fix) {
+                continue;
+            }
+        }
+        seenIds.add(id);
+    }
+    if (hasErrors) {
+        if (logger.isJson()) {
+            logger.json({
+                command: "serialization.validate",
+                duplicates: duplicateCount,
+                fixed: Boolean(options.fix),
+                hasErrors: true,
+            });
+        }
+        throw (0, shared_1.inputError)(options.fix
+            ? "Unresolvable errors were detected. Review logs for details."
+            : "Errors were detected, but no attempt was made to fix them. Pass --fix to attempt fixing.");
+    }
+    if (logger.isJson()) {
+        logger.json({
+            command: "serialization.validate",
+            duplicates: 0,
+            fixed: Boolean(options.fix),
+            hasErrors: false,
+        });
+        return;
+    }
+    logger.info("No errors were detected.", "green");
+};
+exports.runValidate = runValidate;

package/dist/serialization/tasks/watch.d.ts

@@ -0,0 +1,3 @@
+import type { WatchOptions } from "./types";
+export declare const runWatch: (options: WatchOptions) => Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/serialization/tasks/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../../src/serialization/tasks/watch.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C,eAAO,MAAM,QAAQ,GAAU,SAAS,YAAY,KAAG,OAAO,CAAC,IAAI,CAgFlE,CAAC"}

package/dist/serialization/tasks/watch.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWatch = void 0;
+const path_provider_1 = require("../path-provider");
+const item_path_1 = require("../item-path");
+const field_filter_1 = require("../field-filter");
+const sitecore_api_1 = require("../sitecore-api");
+const filesystem_store_1 = require("../filesystem-store");
+const shared_1 = require("./shared");
+const pull_1 = require("./pull");
+const runWatch = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { root, modules } = await (0, shared_1.loadConfigAndModules)(options);
+    const envName = options.environmentName ?? root.defaultEnvironment;
+    const apiTimeoutMs = (0, shared_1.resolveApiTimeoutMs)(root);
+    if (!options.skipPull) {
+        await (0, pull_1.runPull)({ ...options, environmentName: envName });
+    }
+    const subtreesByDb = (0, shared_1.groupSubtreesByDatabase)(modules);
+    const pathProviders = new Map();
+    for (const [database, subtrees] of subtreesByDb) {
+        pathProviders.set(database, new path_provider_1.FilesystemPathProvider(subtrees));
+    }
+    let timestamp = await (0, sitecore_api_1.fetchHistoryTimestamp)(root.environments[envName], {
+        timeoutMs: apiTimeoutMs,
+    });
+    logger.info("Watcher is online! Changes made to serialized items will be automatically pulled.", "magenta");
+    while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const result = await (0, sitecore_api_1.fetchHistoryEntries)(root.environments[envName], timestamp, {
+            timeoutMs: apiTimeoutMs,
+        });
+        timestamp = result.timestamp;
+        if (!result.entries.length) {
+            continue;
+        }
+        for (const entry of result.entries) {
+            const provider = pathProviders.get(entry.database);
+            if (!provider) {
+                continue;
+            }
+            const itemPath = item_path_1.ItemPath.fromPathString(entry.path);
+            const subtrees = subtreesByDb.get(entry.database) ?? [];
+            const matched = subtrees.some((subtree) => subtree.includesPath(itemPath));
+            if (!matched) {
+                continue;
+            }
+            if (entry.changeType === "Recycle") {
+                const metadata = {
+                    id: entry.id,
+                    parentId: "",
+                    templateId: "",
+                    path: itemPath,
+                };
+                await (0, filesystem_store_1.removeItemFromFilesystem)(provider, metadata);
+                if (entry.oldPath) {
+                    const oldItemPath = item_path_1.ItemPath.fromPathString(entry.oldPath);
+                    await (0, filesystem_store_1.removeItemFromFilesystem)(provider, {
+                        id: entry.id,
+                        parentId: "",
+                        templateId: "",
+                        path: oldItemPath,
+                    });
+                }
+                continue;
+            }
+            const filter = (0, field_filter_1.createFieldFilterSet)(root.serialization.excludedFields, []);
+            const data = await (0, sitecore_api_1.fetchItemData)(root.environments[envName], entry.database, entry.id, "SingleItem", filter, { timeoutMs: apiTimeoutMs });
+            if (data.length > 0) {
+                await (0, filesystem_store_1.writeItemToFilesystem)(provider, data[0]);
+            }
+        }
+    }
+};
+exports.runWatch = runWatch;

package/dist/serialization/tasks.d.ts

@@ -0,0 +1,4 @@
+export * from "./tasks/env";
+export * from "./tasks/index";
+export * from "./tasks/types";
+//# sourceMappingURL=tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/serialization/tasks.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

package/dist/serialization/tasks.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tasks/env"), exports);
+__exportStar(require("./tasks/index"), exports);
+__exportStar(require("./tasks/types"), exports);

package/dist/serialization/tree-spec.d.ts

@@ -0,0 +1,51 @@
+import { ItemPath, ItemPathMatchLike } from "./item-path";
+export declare enum TreeScope {
+    SingleItem = "SingleItem",
+    ItemAndChildren = "ItemAndChildren",
+    ItemAndDescendants = "ItemAndDescendants",
+    DescendantsOnly = "DescendantsOnly"
+}
+export declare enum TreeRuleScope {
+    Ignored = "Ignored",
+    SingleItem = "SingleItem",
+    ItemAndChildren = "ItemAndChildren",
+    ItemAndDescendants = "ItemAndDescendants"
+}
+export declare enum AllowedPushOperations {
+    CreateUpdateAndDelete = "CreateUpdateAndDelete",
+    CreateAndUpdate = "CreateAndUpdate",
+    CreateOnly = "CreateOnly"
+}
+export declare class TreeSpecRule {
+    path: ItemPathMatchLike;
+    scope?: TreeRuleScope;
+    allowedPushOperations?: AllowedPushOperations | null;
+    validate(parent: TreeSpec): void;
+    protected validateInternal(parent: TreeSpec, validateScopes: boolean): void;
+    private validateScopes;
+    private validateItemPath;
+    private validateItemPathMatch;
+}
+export declare class FilesystemTreeSpecRule extends TreeSpecRule {
+    alias?: string;
+    validate(parent: TreeSpec): void;
+}
+export declare class TreeSpec {
+    path: ItemPath;
+    scope: TreeScope;
+    allowedPushOperations: AllowedPushOperations;
+    rules: FilesystemTreeSpecRule[];
+    validate(): void;
+    includesPath(path: ItemPath, logger?: (message: string) => void): boolean;
+    getAllowedPushOperationsForItem(path: ItemPath): AllowedPushOperations;
+    protected getRulesThatApplyTo(relativePath: ItemPath): FilesystemTreeSpecRule[];
+}
+export declare class FilesystemTreeSpec extends TreeSpec {
+    name: string;
+    database: string;
+    physicalPath: string;
+    maxRelativePathLength?: number;
+    validate(): void;
+}
+export declare const parseItemPathMatch: (value: string) => ItemPathMatchLike;
+//# sourceMappingURL=tree-spec.d.ts.map

package/dist/serialization/tree-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-spec.d.ts","sourceRoot":"","sources":["../../src/serialization/tree-spec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAiB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGzE,oBAAY,SAAS;IACnB,UAAU,eAAe;IACzB,eAAe,oBAAoB;IACnC,kBAAkB,uBAAuB;IACzC,eAAe,oBAAoB;CACpC;AAED,oBAAY,aAAa;IACvB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,eAAe,oBAAoB;IACnC,kBAAkB,uBAAuB;CAC1C;AAED,oBAAY,qBAAqB;IAC/B,qBAAqB,0BAA0B;IAC/C,eAAe,oBAAoB;IACnC,UAAU,eAAe;CAC1B;AAED,qBAAa,YAAY;IACvB,IAAI,EAAG,iBAAiB,CAAC;IACzB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,qBAAqB,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAErD,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI;IAIhC,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI;IAsB3E,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,gBAAgB;IAqCxB,OAAO,CAAC,qBAAqB;CAgB9B;AAED,qBAAa,sBAAuB,SAAQ,YAAY;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC;IAEN,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI;CAiC1C;AAED,qBAAa,QAAQ;IACnB,IAAI,EAAG,QAAQ,CAAC;IAChB,KAAK,EAAE,SAAS,CAAgC;IAChD,qBAAqB,EAAE,qBAAqB,CAA+C;IAC3F,KAAK,EAAE,sBAAsB,EAAE,CAAM;IAErC,QAAQ,IAAI,IAAI;IAchB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO;IA2DzE,+BAA+B,CAAC,IAAI,EAAE,QAAQ,GAAG,qBAAqB;IAetE,SAAS,CAAC,mBAAmB,CAAC,YAAY,EAAE,QAAQ,GAAG,sBAAsB,EAAE;CAOhF;AAED,qBAAa,kBAAmB,SAAQ,QAAQ;IAC9C,IAAI,EAAG,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAY;IAC5B,YAAY,EAAG,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAEtB,QAAQ,IAAI,IAAI;CAmC1B;AAED,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,iBAMlD,CAAC"}

package/dist/serialization/tree-spec.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseItemPathMatch = exports.FilesystemTreeSpec = exports.TreeSpec = exports.FilesystemTreeSpecRule = exports.TreeSpecRule = exports.AllowedPushOperations = exports.TreeRuleScope = exports.TreeScope = void 0;
+const errors_1 = require("../shared/errors");
+const item_path_1 = require("./item-path");
+const wildcard_1 = require("./wildcard");
+var TreeScope;
+(function (TreeScope) {
+    TreeScope["SingleItem"] = "SingleItem";
+    TreeScope["ItemAndChildren"] = "ItemAndChildren";
+    TreeScope["ItemAndDescendants"] = "ItemAndDescendants";
+    TreeScope["DescendantsOnly"] = "DescendantsOnly";
+})(TreeScope || (exports.TreeScope = TreeScope = {}));
+var TreeRuleScope;
+(function (TreeRuleScope) {
+    TreeRuleScope["Ignored"] = "Ignored";
+    TreeRuleScope["SingleItem"] = "SingleItem";
+    TreeRuleScope["ItemAndChildren"] = "ItemAndChildren";
+    TreeRuleScope["ItemAndDescendants"] = "ItemAndDescendants";
+})(TreeRuleScope || (exports.TreeRuleScope = TreeRuleScope = {}));
+var AllowedPushOperations;
+(function (AllowedPushOperations) {
+    AllowedPushOperations["CreateUpdateAndDelete"] = "CreateUpdateAndDelete";
+    AllowedPushOperations["CreateAndUpdate"] = "CreateAndUpdate";
+    AllowedPushOperations["CreateOnly"] = "CreateOnly";
+})(AllowedPushOperations || (exports.AllowedPushOperations = AllowedPushOperations = {}));
+class TreeSpecRule {
+    validate(parent) {
+        this.validateInternal(parent, true);
+    }
+    validateInternal(parent, validateScopes) {
+        if (!parent) {
+            throw (0, errors_1.createCliError)("TreeSpecRule parent is required.", "CONFIG_INVALID");
+        }
+        if (validateScopes) {
+            this.validateScopes(parent);
+        }
+        if (this.path instanceof item_path_1.ItemPath) {
+            this.validateItemPath(parent, this.path);
+            return;
+        }
+        if (this.path instanceof item_path_1.ItemPathMatch) {
+            this.validateItemPathMatch(parent, this.path);
+            return;
+        }
+        throw (0, errors_1.createCliError)(`Subtree ${parent.path} has a rule with no path.`, "CONFIG_INVALID");
+    }
+    validateScopes(parent) {
+        if (!this.scope) {
+            throw (0, errors_1.createCliError)(`${parent.path} has rule ${this.path?.toPathString()} without scope.`, "CONFIG_INVALID");
+        }
+        if (parent.scope === TreeScope.SingleItem) {
+            throw (0, errors_1.createCliError)(`${parent.path} has scope ${TreeScope.SingleItem} and rules are defined.`, "CONFIG_INVALID");
+        }
+        if (parent.scope === TreeScope.ItemAndChildren &&
+            (this.scope === TreeRuleScope.ItemAndDescendants ||
+                this.scope === TreeRuleScope.ItemAndChildren)) {
+            throw (0, errors_1.createCliError)(`${parent.path} has scope ${TreeScope.ItemAndChildren} and rule ${this.path.toPathString()} has scope ${this.scope}.`, "CONFIG_INVALID");
+        }
+    }
+    validateItemPath(parent, itemPath) {
+        if (itemPath.isDescendantOrSelfOf(parent.path)) {
+            throw (0, errors_1.createCliError)(`Subtree path ${parent.path} contained rule for ${this.path.toPathString()}, which is absolute.`, "CONFIG_INVALID");
+        }
+        if (itemPath.count === 0) {
+            throw (0, errors_1.createCliError)(`Subtree path ${parent.path} contained rule for /, which is the root item.`, "CONFIG_INVALID");
+        }
+        const parentRelative = itemPath.createParentPath();
+        if (!parentRelative) {
+            return;
+        }
+        let currentParentPath = parent.path.concatenate(parentRelative);
+        while (!currentParentPath.equals(parent.path) && currentParentPath.count > 0) {
+            if (!parent.includesPath(currentParentPath)) {
+                throw (0, errors_1.createCliError)(`Subtree path ${parent.path} contained rule for ${this.path.toPathString()}, but ancestor path ${currentParentPath} was not included.`, "CONFIG_INVALID");
+            }
+            const nextParent = currentParentPath.createParentPath();
+            if (!nextParent) {
+                break;
+            }
+            currentParentPath = nextParent;
+        }
+    }
+    validateItemPathMatch(parent, itemPathMatch) {
+        const matchValue = itemPathMatch.toPathString();
+        if (!matchValue.endsWith("*")) {
+            throw (0, errors_1.createCliError)(`Subtree ${parent.path} contained path match rule ${matchValue} without trailing '*'.`, "CONFIG_INVALID");
+        }
+        if (this.scope === TreeRuleScope.SingleItem || this.scope === TreeRuleScope.ItemAndChildren) {
+            throw (0, errors_1.createCliError)(`Subtree ${parent.path} contained wildcard rule ${matchValue} with invalid scope ${this.scope}.`, "CONFIG_INVALID");
+        }
+    }
+}
+exports.TreeSpecRule = TreeSpecRule;
+class FilesystemTreeSpecRule extends TreeSpecRule {
+    validate(parent) {
+        if (!parent) {
+            throw (0, errors_1.createCliError)("FilesystemTreeSpecRule parent is required.", "CONFIG_INVALID");
+        }
+        if (!this.alias) {
+            super.validate(parent);
+            return;
+        }
+        this.validateInternal(parent, false);
+        if (this.scope) {
+            throw (0, errors_1.createCliError)(`Subtree ${parent.path} contained rule for ${this.path.toPathString()} with alias and scope.`, "CONFIG_INVALID");
+        }
+        if (this.path instanceof item_path_1.ItemPathMatch) {
+            throw (0, errors_1.createCliError)(`Subtree ${parent.path} contained match rule ${this.path.toPathString()} that also had an alias.`, "CONFIG_INVALID");
+        }
+        if (!/^[A-Za-z0-9 \-_]+$/.test(this.alias)) {
+            throw (0, errors_1.createCliError)(`Subtree ${parent.path} rule for ${this.path.toPathString()} has invalid alias '${this.alias}'.`, "CONFIG_INVALID");
+        }
+    }
+}
+exports.FilesystemTreeSpecRule = FilesystemTreeSpecRule;
+class TreeSpec {
+    constructor() {
+        this.scope = TreeScope.ItemAndDescendants;
+        this.allowedPushOperations = AllowedPushOperations.CreateUpdateAndDelete;
+        this.rules = [];
+    }
+    validate() {
+        if (!this.path || this.path.count === 0) {
+            throw (0, errors_1.createCliError)("TreeSpec path is null or empty.", "CONFIG_INVALID");
+        }
+        for (const rule of this.rules) {
+            if (!rule.path) {
+                throw (0, errors_1.createCliError)("TreeSpec rule path is null or empty.", "CONFIG_INVALID");
+            }
+            rule.validate(this);
+        }
+    }
+    includesPath(path, logger) {
+        const relativePath = path.createRelativePathFrom(this.path);
+        if (!relativePath) {
+            logger?.("Path was not relative to subtree");
+            return false;
+        }
+        if (this.scope === TreeScope.SingleItem && relativePath.count > 0) {
+            logger?.("Tree scope is SingleItem, and item is a descendant");
+            return false;
+        }
+        if (this.scope === TreeScope.ItemAndChildren && relativePath.count > 1) {
+            logger?.("Tree scope is ItemAndChildren, and item is a grandchild or deeper");
+            return false;
+        }
+        if (this.scope === TreeScope.DescendantsOnly && relativePath.count === 0) {
+            logger?.("Tree scope is DescendantsOnly and item is the root item");
+            return false;
+        }
+        for (const rule of this.getRulesThatApplyTo(relativePath)) {
+            switch (rule.scope) {
+                case TreeRuleScope.Ignored:
+                    logger?.(`Rule ${rule.path.toPathString()} excluded item`);
+                    return false;
+                case TreeRuleScope.ItemAndDescendants:
+                    logger?.(`Rule ${rule.path.toPathString()} included item`);
+                    return true;
+                case TreeRuleScope.SingleItem:
+                case TreeRuleScope.ItemAndChildren: {
+                    if (!(rule.path instanceof item_path_1.ItemPath)) {
+                        throw (0, errors_1.createCliError)("Cannot determine relative path to wildcard.", "CONFIG_INVALID");
+                    }
+                    const ruleRelativePath = relativePath.createRelativePathFrom(rule.path);
+                    if (!ruleRelativePath) {
+                        return false;
+                    }
+                    if (rule.scope === TreeRuleScope.SingleItem && ruleRelativePath.count > 0) {
+                        logger?.("Rule scope SingleItem and item is a descendant");
+                        return false;
+                    }
+                    if (rule.scope === TreeRuleScope.ItemAndChildren && ruleRelativePath.count > 1) {
+                        logger?.("Rule scope ItemAndChildren and item is a grandchild or deeper");
+                        return false;
+                    }
+                    return true;
+                }
+                default:
+                    break;
+            }
+        }
+        logger?.(`Item path matches subtree scope ${this.scope}.`);
+        return true;
+    }
+    getAllowedPushOperationsForItem(path) {
+        const relativePath = path.createRelativePathFrom(this.path);
+        if (!relativePath) {
+            return AllowedPushOperations.CreateOnly;
+        }
+        for (const rule of this.getRulesThatApplyTo(relativePath)) {
+            if (rule.allowedPushOperations) {
+                return rule.allowedPushOperations;
+            }
+        }
+        return this.allowedPushOperations;
+    }
+    getRulesThatApplyTo(relativePath) {
+        if (this.rules.length === 0 || relativePath.count === 0) {
+            return [];
+        }
+        return this.rules.filter((rule) => relativePath.isDescendantOrSelfOf(rule.path));
+    }
+}
+exports.TreeSpec = TreeSpec;
+class FilesystemTreeSpec extends TreeSpec {
+    constructor() {
+        super(...arguments);
+        this.database = "master";
+    }
+    validate() {
+        super.validate();
+        if (!this.name) {
+            throw (0, errors_1.createCliError)(`Subtree name was null or empty for path ${this.path}.`, "CONFIG_INVALID");
+        }
+        if (!this.database) {
+            throw (0, errors_1.createCliError)(`Subtree ${this.name} database was null or empty.`, "CONFIG_INVALID");
+        }
+        if (!this.physicalPath) {
+            throw (0, errors_1.createCliError)(`Subtree ${this.name} physicalPath was null or empty.`, "CONFIG_INVALID");
+        }
+        const aliasSet = new Set();
+        for (const rule of this.rules) {
+            if (!rule.alias) {
+                continue;
+            }
+            if (aliasSet.has(rule.alias.toLowerCase())) {
+                throw (0, errors_1.createCliError)(`Duplicate path alias '${rule.alias}' in subtree ${this.name}.`, "CONFIG_INVALID");
+            }
+            aliasSet.add(rule.alias.toLowerCase());
+        }
+    }
+}
+exports.FilesystemTreeSpec = FilesystemTreeSpec;
+const parseItemPathMatch = (value) => {
+    if ((0, wildcard_1.isWildcard)(value)) {
+        return item_path_1.ItemPathMatch.fromPathMatch(value);
+    }
+    return item_path_1.ItemPath.fromPathString(value);
+};
+exports.parseItemPathMatch = parseItemPathMatch;

package/dist/serialization/types.d.ts

@@ -0,0 +1,75 @@
+import { ItemPath } from "./item-path";
+export type FieldFilter = {
+    fieldId: string;
+    description?: string;
+};
+export type ItemFieldValue = {
+    fieldId: string;
+    nameHint?: string;
+    value: string;
+    blobId?: string | null;
+};
+export type ItemLanguage = {
+    language: string;
+    fields: ItemFieldValue[];
+};
+export type ItemVersion = {
+    language: string;
+    version: number;
+    fields: ItemFieldValue[];
+};
+export type ItemMetadata = {
+    id: string;
+    parentId: string;
+    templateId: string;
+    path: ItemPath;
+    dataSignature?: string;
+    hasChildren?: boolean;
+    database?: string;
+};
+export type ItemData = ItemMetadata & {
+    name: string;
+    branchId?: string | null;
+    sharedFields: ItemFieldValue[];
+    unversionedFields: ItemLanguage[];
+    versions: ItemVersion[];
+};
+export type RolePredicateItem = {
+    domain: string;
+    pattern: string;
+    moduleSourceIdentifier?: string;
+};
+export type UserPredicateItem = {
+    domain: string;
+    pattern: string;
+    moduleSourceIdentifier?: string;
+};
+export type RoleData = {
+    roleName: string;
+    memberOfRoles: string[];
+    serializedItemId?: string;
+};
+export type ProfileProperty = {
+    name: string;
+    content: string;
+    contentType: string;
+    isCustomProperty: boolean;
+};
+export type UserData = {
+    userName: string;
+    email?: string;
+    comment?: string;
+    creationDate: string;
+    isApproved: boolean;
+    roles: string[];
+    profileProperties: ProfileProperty[];
+    serializedItemId?: string;
+};
+export type HistoryEntry = {
+    id: string;
+    path: string;
+    database: string;
+    oldPath?: string | null;
+    changeType: "Create" | "UpdateOrRename" | "Move" | "Recycle";
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/serialization/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,cAAc,EAAE,CAAC;IAC/B,iBAAiB,EAAE,YAAY,EAAE,CAAC;IAClC,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,QAAQ,GAAG,gBAAgB,GAAG,MAAM,GAAG,SAAS,CAAC;CAC9D,CAAC"}

package/dist/serialization/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/serialization/wildcard.d.ts

@@ -0,0 +1,3 @@
+export declare const isWildcard: (candidate: string) => boolean;
+export declare const isWildcardMatch: (input: string, wildcards: string, caseSensitive?: boolean) => boolean;
+//# sourceMappingURL=wildcard.d.ts.map