@lightdash/cli 0.3406.0 → 0.3406.1

package/dist/handlers/contentAsCode/fileNames.d.ts

@@ -0,0 +1,24 @@
+export declare const CODE_FILENAME_MAX_STEM_LENGTH = 200;
+export declare const CODE_FILENAME_HASH_LENGTH = 8;
+export declare const getStableCodeHash: (value: string, length?: number) => string;
+export declare const getContentFileNameStem: ({ value, fallbackPrefix, fallbackHashValue, maxLength, }: {
+    value: string;
+    fallbackPrefix: string;
+    fallbackHashValue?: string;
+    maxLength?: number;
+}) => string;
+export type ContentFileNameInput = {
+    identity: string;
+    displayName: string;
+    preferredFileName?: string;
+};
+export declare const allocateContentFileNames: ({ items, fallbackPrefix, extension, maxStemLength, existingFileNameByIdentity, reservedFileNames, }: {
+    items: ContentFileNameInput[];
+    fallbackPrefix: string;
+    extension?: string;
+    maxStemLength?: number;
+    existingFileNameByIdentity?: ReadonlyMap<string, string>;
+    reservedFileNames?: Iterable<string>;
+}) => string[];
+export declare const assertSafeContentFilePath: (relativePath: string) => void;
+//# sourceMappingURL=fileNames.d.ts.map

package/dist/handlers/contentAsCode/fileNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileNames.d.ts","sourceRoot":"","sources":["../../../src/handlers/contentAsCode/fileNames.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,eAAO,MAAM,iBAAiB,GAC1B,OAAO,MAAM,EACb,SAAQ,MAAkC,KAC3C,MAA2E,CAAC;AAE/E,eAAO,MAAM,sBAAsB,GAAI,0DAKpC;IACC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB,KAAG,MASH,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,qGAOtC;IACC,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0BAA0B,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACxC,KAAG,MAAM,EAgET,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,cAAc,MAAM,KAAG,IAUhE,CAAC"}

package/dist/handlers/contentAsCode/fileNames.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSafeContentFilePath = exports.allocateContentFileNames = exports.getContentFileNameStem = exports.getStableCodeHash = exports.CODE_FILENAME_HASH_LENGTH = exports.CODE_FILENAME_MAX_STEM_LENGTH = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const crypto_1 = require("crypto");
+const path = tslib_1.__importStar(require("path"));
+exports.CODE_FILENAME_MAX_STEM_LENGTH = 200;
+exports.CODE_FILENAME_HASH_LENGTH = 8;
+const getStableCodeHash = (value, length = exports.CODE_FILENAME_HASH_LENGTH) => (0, crypto_1.createHash)('sha256').update(value).digest('hex').slice(0, length);
+exports.getStableCodeHash = getStableCodeHash;
+const getContentFileNameStem = ({ value, fallbackPrefix, fallbackHashValue = value, maxLength = exports.CODE_FILENAME_MAX_STEM_LENGTH, }) => {
+    const normalizedValue = value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '');
+    const stem = /[a-z0-9]/i.test(normalizedValue)
+        ? (0, common_1.generateSlug)(normalizedValue)
+        : `${fallbackPrefix}-${(0, exports.getStableCodeHash)(fallbackHashValue)}`;
+    return stem.slice(0, maxLength);
+};
+exports.getContentFileNameStem = getContentFileNameStem;
+const allocateContentFileNames = ({ items, fallbackPrefix, extension = '.yml', maxStemLength = exports.CODE_FILENAME_MAX_STEM_LENGTH, existingFileNameByIdentity = new Map(), reservedFileNames = [], }) => {
+    const stems = items.map(({ identity, displayName, preferredFileName }) => preferredFileName
+        ? preferredFileName.slice(0, Math.max(0, preferredFileName.length - extension.length))
+        : (0, exports.getContentFileNameStem)({
+            value: displayName,
+            fallbackPrefix,
+            fallbackHashValue: identity,
+            maxLength: maxStemLength,
+        }));
+    const counts = stems.reduce((result, stem) => result.set(stem.toLowerCase(), (result.get(stem.toLowerCase()) ?? 0) + 1), new Map());
+    const usedFileNames = new Set([...reservedFileNames].map((fileName) => fileName.toLowerCase()));
+    return items.map(({ identity, preferredFileName }, index) => {
+        const existingFileName = existingFileNameByIdentity.get(identity);
+        if (existingFileName !== undefined) {
+            usedFileNames.add(existingFileName.toLowerCase());
+            return existingFileName;
+        }
+        const stem = stems[index];
+        const candidateFileName = preferredFileName ??
+            ((counts.get(stem.toLowerCase()) ?? 0) === 1
+                ? `${stem}${extension}`
+                : `${stem.slice(0, maxStemLength - exports.CODE_FILENAME_HASH_LENGTH - 1)}-${(0, exports.getStableCodeHash)(identity)}${extension}`);
+        if (!usedFileNames.has(candidateFileName.toLowerCase())) {
+            usedFileNames.add(candidateFileName.toLowerCase());
+            return candidateFileName;
+        }
+        for (const hashLength of [8, 12, 16, 24, 32, 64]) {
+            const suffix = `-${(0, exports.getStableCodeHash)(identity, hashLength)}`;
+            const candidate = `${stem.slice(0, maxStemLength - suffix.length)}${suffix}${extension}`;
+            if (!usedFileNames.has(candidate.toLowerCase())) {
+                usedFileNames.add(candidate.toLowerCase());
+                return candidate;
+            }
+        }
+        throw new common_1.ParameterError(`Could not allocate a safe filename for content "${identity}"`);
+    });
+};
+exports.allocateContentFileNames = allocateContentFileNames;
+const assertSafeContentFilePath = (relativePath) => {
+    if (relativePath.length === 0 ||
+        path.isAbsolute(relativePath) ||
+        relativePath.split(/[\\/]/).some((segment) => segment === '..')) {
+        throw new common_1.ParameterError(`Unsafe content-as-code file path "${relativePath}"`);
+    }
+};
+exports.assertSafeContentFilePath = assertSafeContentFilePath;

package/dist/handlers/contentAsCode/fileNames.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fileNames.test.d.ts.map

package/dist/handlers/contentAsCode/fileNames.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileNames.test.d.ts","sourceRoot":"","sources":["../../../src/handlers/contentAsCode/fileNames.test.ts"],"names":[],"mappings":""}

package/dist/handlers/contentAsCode/fileNames.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const vitest_1 = require("vitest");
+const fileNames_1 = require("./fileNames");
+(0, vitest_1.describe)('content-as-code filenames', () => {
+    (0, vitest_1.it)('normalizes unicode and preserves compatibility extensions', () => {
+        (0, vitest_1.expect)((0, fileNames_1.allocateContentFileNames)({
+            items: [{ identity: 'malaga', displayName: 'Málaga Finance' }],
+            fallbackPrefix: 'group',
+            extension: '.space.yml',
+        })).toStrictEqual(['malaga-finance.space.yml']);
+    });
+    (0, vitest_1.it)('uses stable identities for unicode-only names and collisions', () => {
+        const hash = (0, crypto_1.createHash)('sha256')
+            .update('party')
+            .digest('hex')
+            .slice(0, 8);
+        (0, vitest_1.expect)((0, fileNames_1.allocateContentFileNames)({
+            items: [{ identity: 'party', displayName: '🎉' }],
+            fallbackPrefix: 'group',
+        })).toStrictEqual([`group-${hash}.yml`]);
+        const names = (0, fileNames_1.allocateContentFileNames)({
+            items: [
+                { identity: 'one', displayName: 'Finance' },
+                { identity: 'two', displayName: 'finance' },
+            ],
+            fallbackPrefix: 'group',
+        });
+        (0, vitest_1.expect)(new Set(names.map((name) => name.toLowerCase())).size).toBe(2);
+    });
+    (0, vitest_1.it)('bounds long stems while retaining a stable collision suffix', () => {
+        const names = (0, fileNames_1.allocateContentFileNames)({
+            items: [
+                { identity: 'one', displayName: 'a'.repeat(500) },
+                { identity: 'two', displayName: 'a'.repeat(500) },
+            ],
+            fallbackPrefix: 'chart',
+        });
+        (0, vitest_1.expect)(names.every((name) => name.length <= 204)).toBe(true);
+        (0, vitest_1.expect)(names[0]).not.toBe(names[1]);
+    });
+    (0, vitest_1.it)('preserves SQL and URI-encoded compatibility profiles', () => {
+        (0, vitest_1.expect)((0, fileNames_1.allocateContentFileNames)({
+            items: [
+                {
+                    identity: 'orders',
+                    displayName: 'Orders',
+                    preferredFileName: 'orders.sql.yml',
+                },
+            ],
+            fallbackPrefix: 'sql-chart',
+            extension: '.sql.yml',
+        })).toStrictEqual(['orders.sql.yml']);
+        (0, vitest_1.expect)((0, fileNames_1.allocateContentFileNames)({
+            items: [
+                {
+                    identity: 'finance/view',
+                    displayName: 'Finance view',
+                    preferredFileName: 'finance%2Fview.yml',
+                },
+            ],
+            fallbackPrefix: 'virtual-view',
+        })).toStrictEqual(['finance%2Fview.yml']);
+    });
+    (0, vitest_1.it)('reuses an existing file owned by the same identity', () => {
+        (0, vitest_1.expect)((0, fileNames_1.allocateContentFileNames)({
+            items: [{ identity: 'finance', displayName: 'New name' }],
+            fallbackPrefix: 'group',
+            existingFileNameByIdentity: new Map([
+                ['finance', 'user-owned-name.yaml'],
+            ]),
+        })).toStrictEqual(['user-owned-name.yaml']);
+    });
+    (0, vitest_1.it)('rejects absolute and parent-traversal paths', () => {
+        (0, vitest_1.expect)(() => (0, fileNames_1.assertSafeContentFilePath)('../secrets.yml')).toThrow('Unsafe');
+        (0, vitest_1.expect)(() => (0, fileNames_1.assertSafeContentFilePath)('/tmp/file.yml')).toThrow('Unsafe');
+    });
+});

package/dist/handlers/contentAsCode/projectResources.d.ts

@@ -0,0 +1,8 @@
+import { type AgentAsCode, type AlertAsCode, type GoogleSheetsSyncAsCode, type ScheduledDeliveryAsCode, type VirtualViewAsCode } from '@lightdash/common';
+import type { CodeResourceDefinition } from './resource';
+export declare const VIRTUAL_VIEW_CODE_RESOURCE: CodeResourceDefinition<VirtualViewAsCode>;
+export declare const AI_AGENT_CODE_RESOURCE: CodeResourceDefinition<AgentAsCode>;
+export declare const SCHEDULED_DELIVERY_CODE_RESOURCE: CodeResourceDefinition<ScheduledDeliveryAsCode>;
+export declare const ALERT_CODE_RESOURCE: CodeResourceDefinition<AlertAsCode>;
+export declare const GOOGLE_SHEETS_CODE_RESOURCE: CodeResourceDefinition<GoogleSheetsSyncAsCode>;
+//# sourceMappingURL=projectResources.d.ts.map

package/dist/handlers/contentAsCode/projectResources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectResources.d.ts","sourceRoot":"","sources":["../../../src/handlers/contentAsCode/projectResources.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,eAAO,MAAM,0BAA0B,EAAE,sBAAsB,CAAC,iBAAiB,CAwB5E,CAAC;AAEN,eAAO,MAAM,sBAAsB,EAAE,sBAAsB,CAAC,WAAW,CAyBtE,CAAC;AA4CF,eAAO,MAAM,gCAAgC,iDAKvC,CAAC;AAEP,eAAO,MAAM,mBAAmB,qCAI9B,CAAC;AAEH,eAAO,MAAM,2BAA2B,gDAKlC,CAAC"}

package/dist/handlers/contentAsCode/projectResources.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOOGLE_SHEETS_CODE_RESOURCE = exports.ALERT_CODE_RESOURCE = exports.SCHEDULED_DELIVERY_CODE_RESOURCE = exports.AI_AGENT_CODE_RESOURCE = exports.VIRTUAL_VIEW_CODE_RESOURCE = void 0;
+const common_1 = require("@lightdash/common");
+exports.VIRTUAL_VIEW_CODE_RESOURCE = {
+    kind: common_1.ContentAsCodeType.VIRTUAL_VIEW,
+    displayLabel: 'virtual view',
+    identityLabel: 'slug',
+    scope: 'project',
+    folderName: 'virtual-views',
+    acceptedExtensions: ['.yml', '.yaml'],
+    fileName: {
+        strategy: 'uriEncodedIdentity',
+        fallbackPrefix: 'virtual-view',
+        extension: '.yml',
+    },
+    dependencies: [],
+    identity: ({ slug }) => slug,
+    displayName: ({ name }) => name,
+    parse: (input, source) => (0, common_1.parseVersionedContentAsCodeDocument)({
+        input,
+        source,
+        resourceLabel: 'virtual view',
+        contentType: common_1.ContentAsCodeType.VIRTUAL_VIEW,
+    }),
+    sort: (left, right) => left.slug.localeCompare(right.slug),
+};
+exports.AI_AGENT_CODE_RESOURCE = {
+    kind: common_1.ContentAsCodeType.AI_AGENT,
+    displayLabel: 'AI agent',
+    identityLabel: 'slug',
+    scope: 'project',
+    folderName: 'ai-agents',
+    acceptedExtensions: ['.yml', '.yaml'],
+    fileName: {
+        strategy: 'identity',
+        fallbackPrefix: 'ai-agent',
+        extension: '.yml',
+    },
+    dependencies: [],
+    recursive: true,
+    identity: ({ slug }) => slug,
+    displayName: ({ name }) => name,
+    parse: (input, source) => (0, common_1.parseVersionedContentAsCodeDocument)({
+        input,
+        source,
+        resourceLabel: 'AI agent',
+        contentType: common_1.ContentAsCodeType.AI_AGENT,
+    }),
+    serialize: ({ updatedAt, downloadedAt, ...agent }) => agent,
+    sort: (left, right) => left.slug.localeCompare(right.slug),
+};
+const scheduledResource = ({ contentType, folderName, label, }) => ({
+    kind: contentType,
+    displayLabel: label,
+    identityLabel: 'slug',
+    scope: 'project',
+    folderName,
+    acceptedExtensions: ['.yml', '.yaml'],
+    fileName: {
+        strategy: 'scheduledResource',
+        fallbackPrefix: contentType,
+        extension: '.yml',
+    },
+    dependencies: ['chart', 'dashboard'],
+    recursive: true,
+    identity: ({ slug }) => slug,
+    displayName: ({ name }) => name,
+    matches: (input) => typeof input === 'object' &&
+        input !== null &&
+        'contentType' in input &&
+        input.contentType === contentType,
+    parse: (input, source) => (0, common_1.parseVersionedContentAsCodeDocument)({
+        input,
+        source,
+        resourceLabel: label,
+        contentType,
+    }),
+    sort: (left, right) => left.slug.localeCompare(right.slug),
+});
+exports.SCHEDULED_DELIVERY_CODE_RESOURCE = scheduledResource({
+    contentType: common_1.ContentAsCodeType.SCHEDULED_DELIVERY,
+    folderName: 'scheduled-deliveries',
+    label: 'scheduled delivery',
+});
+exports.ALERT_CODE_RESOURCE = scheduledResource({
+    contentType: common_1.ContentAsCodeType.ALERT,
+    folderName: 'alerts',
+    label: 'alert',
+});
+exports.GOOGLE_SHEETS_CODE_RESOURCE = scheduledResource({
+    contentType: common_1.ContentAsCodeType.GOOGLE_SHEETS_SYNC,
+    folderName: 'google-sheets',
+    label: 'Google Sheets sync',
+});

package/dist/handlers/contentAsCode/registry.d.ts

@@ -0,0 +1,9 @@
+import { type ContentAsCodeResourceKind } from '@lightdash/common';
+export type CodeResourceRegistration = {
+    kind: ContentAsCodeResourceKind;
+    dependencies: readonly ContentAsCodeResourceKind[];
+};
+export declare const ORGANIZATION_CODE_RESOURCES: readonly CodeResourceRegistration[];
+export declare const PROJECT_CODE_RESOURCES: readonly CodeResourceRegistration[];
+export declare const assertCodeResourceDependencyOrder: (resources: readonly CodeResourceRegistration[]) => void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/handlers/contentAsCode/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/handlers/contentAsCode/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,yBAAyB,EACjC,MAAM,mBAAmB,CAAC;AAY3B,MAAM,MAAM,wBAAwB,GAAG;IACnC,IAAI,EAAE,yBAAyB,CAAC;IAChC,YAAY,EAAE,SAAS,yBAAyB,EAAE,CAAC;CACtD,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,SAAS,wBAAwB,EACH,CAAC;AAEzE,eAAO,MAAM,sBAAsB,EAAE,SAAS,wBAAwB,EAuBrE,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC1C,WAAW,SAAS,wBAAwB,EAAE,KAC/C,IAeF,CAAC"}

package/dist/handlers/contentAsCode/registry.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertCodeResourceDependencyOrder = exports.PROJECT_CODE_RESOURCES = exports.ORGANIZATION_CODE_RESOURCES = void 0;
+const common_1 = require("@lightdash/common");
+const customRoles_1 = require("../organizationContent/customRoles");
+const groups_1 = require("../organizationContent/groups");
+const users_1 = require("../organizationContent/users");
+const projectResources_1 = require("./projectResources");
+exports.ORGANIZATION_CODE_RESOURCES = [customRoles_1.CUSTOM_ROLE_CODE_RESOURCE, users_1.USER_CODE_RESOURCE, groups_1.GROUP_CODE_RESOURCE];
+exports.PROJECT_CODE_RESOURCES = [
+    { kind: common_1.ContentAsCodeType.SPACE, dependencies: [] },
+    projectResources_1.VIRTUAL_VIEW_CODE_RESOURCE,
+    {
+        kind: common_1.ContentAsCodeType.CHART,
+        dependencies: [common_1.ContentAsCodeType.SPACE, common_1.ContentAsCodeType.VIRTUAL_VIEW],
+    },
+    {
+        kind: common_1.ContentAsCodeType.SQL_CHART,
+        dependencies: [common_1.ContentAsCodeType.SPACE],
+    },
+    {
+        kind: common_1.ContentAsCodeType.DASHBOARD,
+        dependencies: [
+            common_1.ContentAsCodeType.SPACE,
+            common_1.ContentAsCodeType.CHART,
+            common_1.ContentAsCodeType.SQL_CHART,
+        ],
+    },
+    projectResources_1.AI_AGENT_CODE_RESOURCE,
+    projectResources_1.SCHEDULED_DELIVERY_CODE_RESOURCE,
+    projectResources_1.ALERT_CODE_RESOURCE,
+    projectResources_1.GOOGLE_SHEETS_CODE_RESOURCE,
+];
+const assertCodeResourceDependencyOrder = (resources) => {
+    const completed = new Set();
+    for (const resource of resources) {
+        const missingDependencies = resource.dependencies.filter((dependency) => !completed.has(dependency));
+        if (missingDependencies.length > 0) {
+            throw new common_1.ParameterError(`Content-as-code resource "${resource.kind}" must run after ${missingDependencies.join(', ')}`);
+        }
+        completed.add(resource.kind);
+    }
+};
+exports.assertCodeResourceDependencyOrder = assertCodeResourceDependencyOrder;

package/dist/handlers/contentAsCode/registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registry.test.d.ts.map

package/dist/handlers/contentAsCode/registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.test.d.ts","sourceRoot":"","sources":["../../../src/handlers/contentAsCode/registry.test.ts"],"names":[],"mappings":""}

package/dist/handlers/contentAsCode/registry.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const registry_1 = require("./registry");
+(0, vitest_1.describe)('content-as-code resource registry', () => {
+    (0, vitest_1.it)('keeps organization dependencies in a valid order', () => {
+        (0, vitest_1.expect)(() => (0, registry_1.assertCodeResourceDependencyOrder)(registry_1.ORGANIZATION_CODE_RESOURCES)).not.toThrow();
+    });
+    (0, vitest_1.it)('keeps project dependencies in a valid order', () => {
+        (0, vitest_1.expect)(() => (0, registry_1.assertCodeResourceDependencyOrder)(registry_1.PROJECT_CODE_RESOURCES)).not.toThrow();
+    });
+    (0, vitest_1.it)('rejects resources registered before their dependencies', () => {
+        (0, vitest_1.expect)(() => (0, registry_1.assertCodeResourceDependencyOrder)([
+            { kind: 'group', dependencies: ['user'] },
+            { kind: 'user', dependencies: [] },
+        ])).toThrow('group');
+    });
+});

package/dist/handlers/contentAsCode/resource.d.ts

@@ -0,0 +1,67 @@
+import { ParameterError, type ContentAsCodeResourceKind, type ContentAsCodeUpsertAction } from '@lightdash/common';
+export type CodeResourceScope = 'project' | 'organization';
+export type CodeResourceDefinition<Document> = {
+    kind: ContentAsCodeResourceKind;
+    displayLabel: string;
+    identityLabel: string;
+    scope: CodeResourceScope;
+    folderName: string;
+    acceptedExtensions: readonly string[];
+    fileName: {
+        strategy: 'normalizedDisplayName' | 'identity' | 'uriEncodedIdentity' | 'space' | 'scheduledResource';
+        fallbackPrefix: string;
+        extension: string;
+    };
+    dependencies: readonly ContentAsCodeResourceKind[];
+    recursive?: boolean;
+    identity: (document: Document) => string;
+    normalizeIdentity?: (identity: string) => string;
+    displayName: (document: Document) => string;
+    matches?: (value: unknown) => boolean;
+    parse: (value: unknown, source: string) => Document;
+    serialize?: (document: Document) => unknown;
+    sort?: (left: Document, right: Document) => number;
+};
+export type CodeFileFailure = {
+    message: string;
+};
+export type CodeResourceFiles<Document> = {
+    files: Array<{
+        filePath: string;
+        document: Document;
+    }>;
+    failures: CodeFileFailure[];
+};
+export type CodeResourceUploadSummary = {
+    created: number;
+    updated: number;
+    unchanged: number;
+    failed: number;
+    failures: CodeFileFailure[];
+};
+export declare class CodeResourcePhaseError extends ParameterError {
+    readonly resource: ContentAsCodeResourceKind;
+    constructor(resource: ContentAsCodeResourceKind, message: string);
+}
+export declare const isCodeResourcePhaseError: (error: unknown) => error is CodeResourcePhaseError;
+export declare const readCodeResourceFiles: <Document>({ definition, basePath, }: {
+    definition: CodeResourceDefinition<Document>;
+    basePath: string;
+}) => Promise<CodeResourceFiles<Document>>;
+export declare const writeCodeResourceDocuments: <Document>({ definition, basePath, documents, }: {
+    definition: CodeResourceDefinition<Document>;
+    basePath: string;
+    documents: Document[];
+}) => Promise<void>;
+export declare const downloadCodeResource: <Document>({ definition, basePath, list, }: {
+    definition: CodeResourceDefinition<Document>;
+    basePath: string;
+    list: () => Promise<Document[]>;
+}) => Promise<number>;
+export declare const uploadCodeResource: <Document>({ definition, basePath, upsert, }: {
+    definition: CodeResourceDefinition<Document>;
+    basePath: string;
+    upsert: (document: Document) => Promise<ContentAsCodeUpsertAction>;
+}) => Promise<CodeResourceUploadSummary>;
+export declare const assertCodeResourceFilesValid: <Document>(result: CodeResourceFiles<Document>) => void;
+//# sourceMappingURL=resource.d.ts.map

package/dist/handlers/contentAsCode/resource.d.ts.map

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

package/dist/handlers/contentAsCode/resource.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertCodeResourceFilesValid = exports.uploadCodeResource = exports.downloadCodeResource = exports.writeCodeResourceDocuments = exports.readCodeResourceFiles = exports.isCodeResourcePhaseError = exports.CodeResourcePhaseError = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-await-in-loop */
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const yaml = tslib_1.__importStar(require("js-yaml"));
+const path = tslib_1.__importStar(require("path"));
+const fileNames_1 = require("./fileNames");
+class CodeResourcePhaseError extends common_1.ParameterError {
+    resource;
+    constructor(resource, message) {
+        super(message);
+        this.name = 'CodeResourcePhaseError';
+        this.resource = resource;
+    }
+}
+exports.CodeResourcePhaseError = CodeResourcePhaseError;
+const isCodeResourcePhaseError = (error) => error instanceof CodeResourcePhaseError;
+exports.isCodeResourcePhaseError = isCodeResourcePhaseError;
+const isAcceptedFile = (definition, entry) => entry.isFile() &&
+    definition.acceptedExtensions.some((extension) => entry.name.endsWith(extension));
+const normalizeIdentity = (definition, identity) => definition.normalizeIdentity?.(identity) ?? identity;
+const readCodeResourceFiles = async ({ definition, basePath, }) => {
+    const folder = path.join(basePath, definition.folderName);
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(folder, {
+            withFileTypes: true,
+            recursive: definition.recursive,
+        });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { files: [], failures: [] };
+        }
+        throw error;
+    }
+    const parsed = { files: [], failures: [] };
+    for (const entry of entries
+        .filter((item) => isAcceptedFile(definition, item))
+        .sort((left, right) => left.name.localeCompare(right.name))) {
+        const filePath = path.join(entry.parentPath ?? folder, entry.name);
+        try {
+            const value = yaml.load(await fs_1.promises.readFile(filePath, 'utf8'));
+            if (!definition.matches || definition.matches(value)) {
+                const document = definition.parse(value, filePath);
+                parsed.files.push({ filePath, document });
+            }
+        }
+        catch (error) {
+            parsed.failures.push({
+                message: `Invalid ${definition.displayLabel} file "${filePath}": ${(0, common_1.getErrorMessage)(error)}`,
+            });
+        }
+    }
+    const filesByIdentity = parsed.files.reduce((result, file) => {
+        const identity = normalizeIdentity(definition, definition.identity(file.document));
+        result.set(identity, [...(result.get(identity) ?? []), file]);
+        return result;
+    }, new Map());
+    const duplicateIdentities = new Set([...filesByIdentity.entries()]
+        .filter(([, files]) => files.length > 1)
+        .map(([identity]) => identity));
+    for (const identity of [...duplicateIdentities].sort()) {
+        for (const file of filesByIdentity.get(identity) ?? []) {
+            parsed.failures.push({
+                message: `Duplicate ${definition.displayLabel} ${definition.identityLabel} "${identity}" in "${file.filePath}"`,
+            });
+        }
+    }
+    parsed.files = parsed.files.filter(({ document }) => !duplicateIdentities.has(normalizeIdentity(definition, definition.identity(document))));
+    return parsed;
+};
+exports.readCodeResourceFiles = readCodeResourceFiles;
+const writeCodeResourceDocuments = async ({ definition, basePath, documents, }) => {
+    const sortedDocuments = definition.sort
+        ? [...documents].sort(definition.sort)
+        : documents;
+    const folder = path.join(basePath, definition.folderName);
+    await fs_1.promises.mkdir(folder, { recursive: true });
+    const current = await (0, exports.readCodeResourceFiles)({ definition, basePath });
+    const existingFileNameByIdentity = new Map(current.files.map(({ filePath, document }) => [
+        definition.identity(document),
+        path.basename(filePath),
+    ]));
+    const reservedFileNames = (await fs_1.promises.readdir(folder, { withFileTypes: true }))
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name);
+    const preferredFileName = (document) => {
+        switch (definition.fileName.strategy) {
+            case 'identity':
+                return `${definition.identity(document)}${definition.fileName.extension}`;
+            case 'uriEncodedIdentity':
+                return `${encodeURIComponent(definition.identity(document))}${definition.fileName.extension}`;
+            default:
+                return undefined;
+        }
+    };
+    const fileNames = (0, fileNames_1.allocateContentFileNames)({
+        items: sortedDocuments.map((document) => ({
+            identity: definition.identity(document),
+            displayName: definition.displayName(document),
+            preferredFileName: preferredFileName(document),
+        })),
+        fallbackPrefix: definition.fileName.fallbackPrefix,
+        extension: definition.fileName.extension,
+        existingFileNameByIdentity,
+        reservedFileNames,
+    });
+    await Promise.all(sortedDocuments.map((document, index) => fs_1.promises.writeFile(path.join(folder, fileNames[index]), yaml.dump(definition.serialize?.(document) ?? document, {
+        quotingType: '"',
+        sortKeys: true,
+    }))));
+    const downloadedIdentities = new Set(sortedDocuments.map((document) => normalizeIdentity(definition, definition.identity(document))));
+    await Promise.all(current.files
+        .filter(({ document }) => !downloadedIdentities.has(normalizeIdentity(definition, definition.identity(document))))
+        .map(({ filePath }) => fs_1.promises.unlink(filePath)));
+};
+exports.writeCodeResourceDocuments = writeCodeResourceDocuments;
+const downloadCodeResource = async ({ definition, basePath, list, }) => {
+    const documents = await list();
+    await (0, exports.writeCodeResourceDocuments)({ definition, basePath, documents });
+    return documents.length;
+};
+exports.downloadCodeResource = downloadCodeResource;
+const getActionCountKey = (action) => {
+    switch (action) {
+        case common_1.PromotionAction.CREATE:
+            return 'created';
+        case common_1.PromotionAction.UPDATE:
+            return 'updated';
+        case common_1.PromotionAction.NO_CHANGES:
+            return 'unchanged';
+        default:
+            return (0, common_1.assertUnreachable)(action, 'Unsupported content-as-code action');
+    }
+};
+const uploadCodeResource = async ({ definition, basePath, upsert, }) => {
+    const { files, failures } = await (0, exports.readCodeResourceFiles)({
+        definition,
+        basePath,
+    });
+    const summary = {
+        created: 0,
+        updated: 0,
+        unchanged: 0,
+        failed: 0,
+        failures,
+    };
+    for (const { filePath, document } of files) {
+        try {
+            summary[getActionCountKey(await upsert(document))] += 1;
+        }
+        catch (error) {
+            summary.failures.push({
+                message: `Invalid ${definition.displayLabel} file "${filePath}": ${(0, common_1.getErrorMessage)(error)}`,
+            });
+        }
+    }
+    summary.failed = summary.failures.length;
+    return summary;
+};
+exports.uploadCodeResource = uploadCodeResource;
+const assertCodeResourceFilesValid = (result) => {
+    if (result.failures.length > 0) {
+        throw new common_1.ParameterError(result.failures.map(({ message }) => message).join('\n'));
+    }
+};
+exports.assertCodeResourceFilesValid = assertCodeResourceFilesValid;

package/dist/handlers/contentAsCode/resource.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resource.test.d.ts.map

package/dist/handlers/contentAsCode/resource.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.test.d.ts","sourceRoot":"","sources":["../../../src/handlers/contentAsCode/resource.test.ts"],"names":[],"mappings":""}