@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/serialization/path-provider.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesystemPathProvider = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const errors_1 = require("../shared/errors");
+const item_path_1 = require("./item-path");
+const invalidFileNameCharacters = new Set([
+    '"',
+    "<",
+    ">",
+    "|",
+    "\0",
+    ...Array.from({ length: 31 }, (_, idx) => String.fromCharCode(idx + 1)),
+    ":",
+    "*",
+    "?",
+    "\\",
+    "/",
+    "$",
+].map((c) => c));
+const invalidFileNames = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9",
+].map((name) => name.toLowerCase()));
+class PathIndexTree {
+    constructor() {
+        this.root = {
+            value: [],
+            children: new Map(),
+        };
+        this.valueCount = 0;
+    }
+    addPathData(pathValue, data) {
+        let current = this.root;
+        for (const segment of pathValue.toPathString().split("/").filter(Boolean)) {
+            const key = segment.toLowerCase();
+            if (!current.children.has(key)) {
+                current.children.set(key, { value: [], children: new Map() });
+            }
+            current = current.children.get(key);
+        }
+        current.value.push(data);
+        this.valueCount += 1;
+    }
+    *getAncestorAndSelfPathData(pathValue) {
+        let current = this.root;
+        const segments = pathValue.toPathString().split("/").filter(Boolean);
+        for (const segment of segments) {
+            const child = current.children.get(segment.toLowerCase());
+            if (!child) {
+                return;
+            }
+            for (const value of child.value) {
+                yield value;
+            }
+            current = child;
+        }
+    }
+}
+class SubtreeFilesystemPathProvider {
+    constructor(spec) {
+        this.validPathSegmentsCache = new Map();
+        this.spec = spec;
+        this.aliases = this.createPathAliases(spec.rules);
+    }
+    getPhysicalPathForItemPath(itemPath, extension) {
+        if (!extension.startsWith(".")) {
+            throw (0, errors_1.createCliError)("Extension must start with a period.", "INPUT_INVALID");
+        }
+        const childPath = this.getChildrenPathForItemPath(itemPath);
+        if (!childPath) {
+            return null;
+        }
+        return childPath + extension;
+    }
+    getChildrenPathsForItemPath(itemPath) {
+        const primary = this.getChildrenPathForItemPath(itemPath);
+        if (!primary) {
+            return null;
+        }
+        const shortened = this.getShortenedChildrenPathForItemPath(itemPath);
+        if (primary.toLowerCase() === shortened.toLowerCase()) {
+            return [primary];
+        }
+        return [primary, shortened];
+    }
+    toString() {
+        return this.spec.physicalPath;
+    }
+    getChildrenPathForItemPath(itemPath) {
+        const relativePath = this.processItemPathToPhysicalRelativePath(itemPath);
+        if (!relativePath) {
+            return null;
+        }
+        const hashedPath = this.applyPathLengthHashes(relativePath);
+        return this.convertSubtreeRelativeItemPathToPhysicalPath(hashedPath);
+    }
+    getShortenedChildrenPathForItemPath(itemPath) {
+        const relativePath = this.processItemPathToPhysicalRelativePath(itemPath);
+        if (!relativePath) {
+            return "";
+        }
+        const stripped = item_path_1.ItemPath.fromSegments(relativePath.toPathString().split("/").filter(Boolean).slice(1));
+        const hashed = this.computePathHash(stripped);
+        return this.convertSubtreeRelativeItemPathToPhysicalPath(hashed);
+    }
+    processItemPathToPhysicalRelativePath(itemPath) {
+        if (!this.spec.includesPath(itemPath)) {
+            return null;
+        }
+        const subtreeRelativePath = itemPath.createRelativePathFrom(this.spec.path);
+        if (!subtreeRelativePath) {
+            return null;
+        }
+        const aliasApplied = this.tryApplyPathAliases(subtreeRelativePath);
+        if (aliasApplied) {
+            return aliasApplied;
+        }
+        const baseSegmentIndex = Math.max(itemPath.count - subtreeRelativePath.count - 1, 0);
+        return subtreeRelativePath.prepend(itemPath.toPathString().split("/").filter(Boolean)[baseSegmentIndex]);
+    }
+    convertSubtreeRelativeItemPathToPhysicalPath(relativePath) {
+        const parts = relativePath.toPathString().split("/").filter(Boolean);
+        const normalized = parts.map((segment) => this.convertItemPathSegmentToValidFilesystemPathSegment(segment));
+        return node_path_1.default.join(this.spec.physicalPath, ...normalized);
+    }
+    convertItemPathSegmentToValidFilesystemPathSegment(segment) {
+        if (this.validPathSegmentsCache.has(segment)) {
+            return this.validPathSegmentsCache.get(segment);
+        }
+        const trimmed = segment.trim();
+        const chars = trimmed
+            .split("")
+            .map((char) => (invalidFileNameCharacters.has(char) ? "#" : char));
+        let finalName = chars.join("");
+        if (invalidFileNames.has(finalName.toLowerCase())) {
+            finalName = "#" + finalName;
+        }
+        this.validPathSegmentsCache.set(segment, finalName);
+        return finalName;
+    }
+    createPathAliases(rules) {
+        const results = [];
+        for (const rule of rules) {
+            if (!rule.alias || !(rule.path instanceof item_path_1.ItemPath)) {
+                continue;
+            }
+            results.push({
+                aliasRulePath: rule.path,
+                aliasPath: item_path_1.ItemPath.fromPathString("/" + rule.alias),
+            });
+        }
+        return results;
+    }
+    tryApplyPathAliases(relativePath) {
+        if (!this.aliases.length) {
+            return null;
+        }
+        let currentPath = relativePath;
+        while (currentPath) {
+            const found = this.aliases.find((alias) => alias.aliasRulePath.equals(currentPath));
+            if (found) {
+                const aliasRelative = relativePath.createRelativePathFrom(found.aliasRulePath);
+                if (!aliasRelative) {
+                    return null;
+                }
+                const baseSegmentIndex = Math.max(relativePath.count - aliasRelative.count - 1, 0);
+                const aliasRelativeWithRoot = aliasRelative.prepend(relativePath.toPathString().split("/").filter(Boolean)[baseSegmentIndex]);
+                return found.aliasPath.concatenate(aliasRelativeWithRoot);
+            }
+            currentPath = currentPath.createParentPath();
+        }
+        return null;
+    }
+    computePathHash(relativePath) {
+        const hash = node_crypto_1.default
+            .createHash("sha256")
+            .update(relativePath.toPathString(), "utf8")
+            .digest("hex")
+            .substring(0, 16);
+        return item_path_1.ItemPath.fromSegments([hash]);
+    }
+    applyPathLengthHashes(relativePath) {
+        const maxLength = this.spec.maxRelativePathLength ?? 120;
+        const relativeItemPath = item_path_1.ItemPath.fromSegments(relativePath.toPathString().split("/").filter(Boolean).slice(1));
+        if (relativeItemPath.pathLength <= maxLength) {
+            return relativePath;
+        }
+        if (maxLength < 16) {
+            throw (0, errors_1.createCliError)(`MaxRelativePathLength ${maxLength} is below minimum value of 16.`, "CONFIG_INVALID");
+        }
+        let currentPath = relativeItemPath;
+        const targetMultiple = Math.floor(relativeItemPath.pathLength / maxLength);
+        let currentMultiple = currentPath.pathLength / maxLength;
+        while (currentPath && currentMultiple > targetMultiple) {
+            currentPath = currentPath.createParentPath();
+            if (currentPath) {
+                currentMultiple = currentPath.pathLength / maxLength;
+            }
+        }
+        if (!currentPath || currentPath.count === 0) {
+            throw (0, errors_1.createCliError)(`The path ${relativeItemPath} could not be stored because its length could not be reduced below the maximum path length ${maxLength}.`, "INPUT_INVALID");
+        }
+        const relative = relativeItemPath.createRelativePathFrom(currentPath);
+        if (!relative) {
+            return relativePath;
+        }
+        const hashed = this.computePathHash(currentPath);
+        return hashed.concatenate(relative);
+    }
+}
+class FilesystemPathProvider {
+    constructor(subtreeSpecs) {
+        this.subtrees = new PathIndexTree();
+        this.examplePath = "";
+        for (const spec of subtreeSpecs) {
+            const subtree = new SubtreeFilesystemPathProvider(spec);
+            this.subtrees.addPathData(spec.path, subtree);
+            this.examplePath = spec.physicalPath;
+        }
+    }
+    getPhysicalPathForItemPath(itemPath, extension) {
+        return this.invokeUnique(itemPath, (subtree) => subtree.getPhysicalPathForItemPath(itemPath, extension));
+    }
+    getChildrenPathsForItemPath(itemPath) {
+        return this.invokeUnique(itemPath, (subtree) => subtree.getChildrenPathsForItemPath(itemPath));
+    }
+    toString() {
+        return `${this.subtrees.valueCount} subtrees, e.g. ${this.examplePath}`;
+    }
+    invokeUnique(itemPath, fn) {
+        let result = null;
+        let resultFoundOn = null;
+        for (const subtree of this.subtrees.getAncestorAndSelfPathData(itemPath)) {
+            const subtreeResult = fn(subtree);
+            if (subtreeResult != null && result != null) {
+                throw (0, errors_1.createCliError)(`The item path ${itemPath} was included in multiple places. Found valid file paths within these modules: ${resultFoundOn} and ${subtree}`, "CONFIG_INVALID");
+            }
+            if (subtreeResult != null) {
+                resultFoundOn = subtree;
+                result = subtreeResult;
+            }
+        }
+        return result;
+    }
+}
+exports.FilesystemPathProvider = FilesystemPathProvider;

package/dist/serialization/signature.d.ts

@@ -0,0 +1,4 @@
+import { ItemData } from "./types";
+export declare const createDataSignatureBase: (item: ItemData, forceBlobRestore?: boolean) => string;
+export declare const createSignature: (signatureBase: string | null) => string | null;
+//# sourceMappingURL=signature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src/serialization/signature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAanC,eAAO,MAAM,uBAAuB,GAAI,MAAM,QAAQ,EAAE,0BAAwB,KAAG,MA0DlF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,eAAe,MAAM,GAAG,IAAI,KAAG,MAAM,GAAG,IAOvE,CAAC"}

package/dist/serialization/signature.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignature = exports.createDataSignatureBase = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const DEFAULT_EXCLUDED_FIELDS = new Set([
+    "B1E16562-F3F9-4DDD-84CA-6E099950ECC0", // LastRun
+    "52807595-0F8F-4B20-8D2A-CB71D28C6103", // Owner
+    "8CDC337E-A112-42FB-BBB4-4143751E123F", // Revision
+    "D9CF14B1-FA16-4BA6-9288-E8A174D4D522", // Updated
+    "BADD9CF9-53E0-4D0C-BCC0-2D784C282F6A", // UpdatedBy
+    "001DD393-96C5-490B-924A-B0F25CD9EFD8", // Lock
+]);
+const stripNewLines = (value) => value.replace(/\r/g, "").replace(/\n/g, "");
+const createDataSignatureBase = (item, forceBlobRestore = false) => {
+    const basis = [item.templateId];
+    const processField = (field) => {
+        const fieldId = field.fieldId?.toUpperCase();
+        if (!fieldId || DEFAULT_EXCLUDED_FIELDS.has(fieldId)) {
+            return;
+        }
+        basis.push(fieldId);
+        if (field.blobId) {
+            basis.push(field.blobId.toString());
+            if (forceBlobRestore) {
+                basis.push(field.value || "blobNotExists");
+            }
+            return;
+        }
+        basis.push(stripNewLines(field.value ?? ""));
+    };
+    const shared = [...item.sharedFields].sort((a, b) => a.fieldId.localeCompare(b.fieldId));
+    for (const field of shared) {
+        processField(field);
+    }
+    const unversioned = [...item.unversionedFields].sort((a, b) => a.language.localeCompare(b.language));
+    for (const language of unversioned) {
+        basis.push(language.language);
+        const fields = [...language.fields].sort((a, b) => a.fieldId.localeCompare(b.fieldId));
+        for (const field of fields) {
+            processField(field);
+        }
+    }
+    const versions = [...item.versions].sort((a, b) => {
+        const lang = a.language.localeCompare(b.language);
+        if (lang !== 0) {
+            return lang;
+        }
+        return a.version - b.version;
+    });
+    for (const version of versions) {
+        basis.push(version.language);
+        basis.push(version.version.toString());
+        const fields = [...version.fields].sort((a, b) => a.fieldId.localeCompare(b.fieldId));
+        for (const field of fields) {
+            processField(field);
+        }
+    }
+    return basis.join("");
+};
+exports.createDataSignatureBase = createDataSignatureBase;
+const createSignature = (signatureBase) => {
+    if (!signatureBase) {
+        return null;
+    }
+    const hash = node_crypto_1.default.createHash("sha256").update(signatureBase, "utf8").digest("base64");
+    return hash;
+};
+exports.createSignature = createSignature;

package/dist/serialization/sitecore-api/auth.d.ts

@@ -0,0 +1,31 @@
+import { EnvironmentConfiguration } from "../../config";
+export type AccessTokenResult = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn?: number;
+    tokenType?: string;
+};
+export type DeviceAuthorizationResult = {
+    deviceCode: string;
+    userCode?: string;
+    verificationUri: string;
+    verificationUriComplete?: string;
+    expiresIn: number;
+    interval: number;
+    message?: string;
+};
+export declare const requestDeviceAuthorization: (environment: EnvironmentConfiguration, scope?: string) => Promise<DeviceAuthorizationResult>;
+export declare const pollDeviceToken: (environment: EnvironmentConfiguration, device: DeviceAuthorizationResult) => Promise<AccessTokenResult>;
+/**
+ * Default OAuth audience for Sitecore Cloud APIs (Deploy + Authoring +
+ * Sites). When the env profile doesn't pin an explicit `audience`,
+ * Auth0 falls back to whatever default is configured for the M2M
+ * client. Some org-scoped clients are configured with internal-only
+ * audiences they aren't authorized to mint tokens for, so we always
+ * send this audience explicitly on the request.
+ */
+export declare const DEFAULT_SITECORE_API_AUDIENCE = "https://api.sitecorecloud.io";
+export declare const requestClientCredentialsToken: (environment: EnvironmentConfiguration, scope?: string) => Promise<AccessTokenResult>;
+export declare const requestPasswordToken: (environment: EnvironmentConfiguration, username: string, password: string, scope?: string) => Promise<AccessTokenResult>;
+export declare const getAccessToken: (environment: EnvironmentConfiguration) => Promise<string | undefined>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/serialization/sitecore-api/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/serialization/sitecore-api/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AA6EpD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AA0CF,eAAO,MAAM,0BAA0B,GACrC,aAAa,wBAAwB,EACrC,QAAQ,MAAM,KACb,OAAO,CAAC,yBAAyB,CAqDnC,CAAC;AAOF,eAAO,MAAM,eAAe,GAC1B,aAAa,wBAAwB,EACrC,QAAQ,yBAAyB,KAChC,OAAO,CAAC,iBAAiB,CAuE3B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,iCAAiC,CAAC;AAE5E,eAAO,MAAM,6BAA6B,GACxC,aAAa,wBAAwB,EACrC,QAAQ,MAAM,KACb,OAAO,CAAC,iBAAiB,CAmB3B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,aAAa,wBAAwB,EACrC,UAAU,MAAM,EAChB,UAAU,MAAM,EAChB,QAAQ,MAAM,KACb,OAAO,CAAC,iBAAiB,CAyB3B,CAAC;AAiCF,eAAO,MAAM,cAAc,GACzB,aAAa,wBAAwB,KACpC,OAAO,CAAC,MAAM,GAAG,SAAS,CA6D5B,CAAC"}