codify-plugin-lib 1.0.76 → 1.0.77

package/dist/plugin/plugin.js

@@ -0,0 +1,83 @@
+import { Plan } from '../plan/plan.js';
+import { ResourceController } from '../resource/resource-controller.js';
+import { splitUserConfig } from '../utils/utils.js';
+export class Plugin {
+    name;
+    resourceControllers;
+    planStorage;
+    constructor(name, resourceControllers) {
+        this.name = name;
+        this.resourceControllers = resourceControllers;
+        this.planStorage = new Map();
+    }
+    static create(name, resources) {
+        const controllers = resources
+            .map((resource) => new ResourceController(resource));
+        const controllersMap = new Map(controllers.map((r) => [r.typeId, r]));
+        return new Plugin(name, controllersMap);
+    }
+    async initialize() {
+        for (const controller of this.resourceControllers.values()) {
+            await controller.initialize();
+        }
+        return {
+            resourceDefinitions: [...this.resourceControllers.values()]
+                .map((r) => ({
+                dependencies: r.dependencies,
+                type: r.typeId,
+            }))
+        };
+    }
+    async validate(data) {
+        const validationResults = [];
+        for (const config of data.configs) {
+            if (!this.resourceControllers.has(config.type)) {
+                throw new Error(`Resource type not found: ${config.type}`);
+            }
+            const { parameters, coreParameters } = splitUserConfig(config);
+            const validation = await this.resourceControllers
+                .get(config.type)
+                .validate(parameters, coreParameters);
+            validationResults.push(validation);
+        }
+        await this.crossValidateResources(data.configs);
+        return {
+            resourceValidations: validationResults
+        };
+    }
+    async plan(data) {
+        const type = data.desired?.type ?? data.state?.type;
+        if (!type || !this.resourceControllers.has(type)) {
+            throw new Error(`Resource type not found: ${type}`);
+        }
+        const plan = await this.resourceControllers.get(type).plan(data.desired ?? null, data.state ?? null, data.isStateful);
+        this.planStorage.set(plan.id, plan);
+        return plan.toResponse();
+    }
+    async apply(data) {
+        if (!data.planId && !data.plan) {
+            throw new Error('For applies either plan or planId must be supplied');
+        }
+        const plan = this.resolvePlan(data);
+        const resource = this.resourceControllers.get(plan.getResourceType());
+        if (!resource) {
+            throw new Error('Malformed plan with resource that cannot be found');
+        }
+        await resource.apply(plan);
+    }
+    resolvePlan(data) {
+        const { plan: planRequest, planId } = data;
+        if (planId) {
+            if (!this.planStorage.has(planId)) {
+                throw new Error(`Plan with id: ${planId} was not found`);
+            }
+            return this.planStorage.get(planId);
+        }
+        if (!planRequest?.resourceType || !this.resourceControllers.has(planRequest.resourceType)) {
+            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
+        }
+        const resource = this.resourceControllers.get(planRequest.resourceType);
+        return Plan.fromResponse(planRequest, resource.parsedSettings.defaultValues);
+    }
+    async crossValidateResources(configs) { }
+}

package/dist/resource/config-parser.d.ts

@@ -0,0 +1,14 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { StatefulParameter } from './stateful-parameter.js';
+export declare class ConfigParser<T extends StringIndexedObject> {
+    private readonly desiredConfig;
+    private readonly stateConfig;
+    private statefulParametersMap;
+    constructor(desiredConfig: Partial<T> & ResourceConfig | null, stateConfig: Partial<T> & ResourceConfig | null, statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>);
+    get coreParameters(): ResourceConfig;
+    get desiredParameters(): Partial<T> | null;
+    get stateParameters(): Partial<T> | null;
+    get allParameters(): Partial<T>;
+    get allNonStatefulParameters(): Partial<T>;
+    get allStatefulParameters(): Partial<T>;
+}

package/dist/resource/config-parser.js

@@ -0,0 +1,48 @@
+import { splitUserConfig } from '../utils/utils.js';
+export class ConfigParser {
+    desiredConfig;
+    stateConfig;
+    statefulParametersMap;
+    constructor(desiredConfig, stateConfig, statefulParameters) {
+        this.desiredConfig = desiredConfig;
+        this.stateConfig = stateConfig;
+        this.statefulParametersMap = statefulParameters;
+    }
+    get coreParameters() {
+        const desiredCoreParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).coreParameters : undefined;
+        const currentCoreParameters = this.stateConfig ? splitUserConfig(this.stateConfig).coreParameters : undefined;
+        if (!desiredCoreParameters && !currentCoreParameters) {
+            throw new Error(`Unable to parse resource core parameters from:
+       
+ Desired: ${JSON.stringify(this.desiredConfig, null, 2)}
+  
+ Current: ${JSON.stringify(this.stateConfig, null, 2)}`);
+        }
+        return desiredCoreParameters ?? currentCoreParameters;
+    }
+    get desiredParameters() {
+        if (!this.desiredConfig) {
+            return null;
+        }
+        const { parameters } = splitUserConfig(this.desiredConfig);
+        return parameters;
+    }
+    get stateParameters() {
+        if (!this.stateConfig) {
+            return null;
+        }
+        const { parameters } = splitUserConfig(this.stateConfig);
+        return parameters;
+    }
+    get allParameters() {
+        return { ...this.desiredParameters, ...this.stateParameters };
+    }
+    get allNonStatefulParameters() {
+        const { allParameters, statefulParametersMap, } = this;
+        return Object.fromEntries(Object.entries(allParameters).filter(([key]) => !statefulParametersMap.has(key)));
+    }
+    get allStatefulParameters() {
+        const { allParameters, statefulParametersMap } = this;
+        return Object.fromEntries(Object.entries(allParameters).filter(([key]) => statefulParametersMap.has(key)));
+    }
+}

package/dist/resource/parsed-resource-settings.d.ts

@@ -0,0 +1,26 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { ParameterSetting, ResourceSettings } from './resource-settings.js';
+import { StatefulParameter as StatefulParameterImpl } from './stateful-parameter.js';
+export declare class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
+    private cache;
+    id: string;
+    schema?: unknown;
+    allowMultiple?: {
+        matcher: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+    } | undefined;
+    removeStatefulParametersBeforeDestroy?: boolean | undefined;
+    dependencies?: string[] | undefined;
+    inputTransformation?: ((desired: Partial<T>) => unknown) | undefined;
+    private settings;
+    constructor(settings: ResourceSettings<T>);
+    get typeId(): string;
+    get statefulParameters(): Map<keyof T, StatefulParameterImpl<T, T[keyof T]>>;
+    get parameterSettings(): Record<keyof T, ParameterSetting>;
+    get defaultValues(): Partial<Record<keyof T, unknown>>;
+    get inputTransformations(): Partial<Record<keyof T, (a: unknown) => unknown>>;
+    get statefulParameterOrder(): Map<keyof T, number>;
+    private validateSettings;
+    private validateParameterEqualsFn;
+    private resolveEqualsFn;
+    private getFromCacheOrCreate;
+}

package/dist/resource/parsed-resource-settings.js

@@ -0,0 +1,126 @@
+import { areArraysEqual } from '../utils/utils.js';
+import { ParameterEqualsDefaults } from './resource-settings.js';
+export class ParsedResourceSettings {
+    cache = new Map();
+    id;
+    schema;
+    allowMultiple;
+    removeStatefulParametersBeforeDestroy;
+    dependencies;
+    inputTransformation;
+    settings;
+    constructor(settings) {
+        this.settings = settings;
+        this.id = settings.id;
+        this.schema = settings.schema;
+        this.allowMultiple = settings.allowMultiple;
+        this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
+        this.dependencies = settings.dependencies;
+        this.inputTransformation = settings.inputTransformation;
+        this.validateSettings();
+    }
+    get typeId() {
+        return this.id;
+    }
+    get statefulParameters() {
+        return this.getFromCacheOrCreate('statefulParameters', () => {
+            const statefulParameters = Object.entries(this.settings.parameterSettings ?? {})
+                .filter(([, p]) => p?.type === 'stateful')
+                .map(([k, v]) => [k, v.definition]);
+            return new Map(statefulParameters);
+        });
+    }
+    get parameterSettings() {
+        return this.getFromCacheOrCreate('parameterSetting', () => {
+            const settings = Object.entries(this.settings.parameterSettings ?? {})
+                .map(([k, v]) => [k, v])
+                .map(([k, v]) => {
+                v.isEqual = this.resolveEqualsFn(v, k);
+                return [k, v];
+            });
+            return Object.fromEntries(settings);
+        });
+    }
+    get defaultValues() {
+        return this.getFromCacheOrCreate('defaultValues', () => {
+            if (!this.settings.parameterSettings) {
+                return {};
+            }
+            const defaultValues = Object.fromEntries(Object.entries(this.settings.parameterSettings)
+                .filter(([, v]) => v.default !== undefined)
+                .map(([k, v]) => [k, v.default]));
+            const statefulParameterDefaultValues = Object.fromEntries(Object.entries(this.settings.parameterSettings)
+                .filter(([, v]) => v?.type === 'stateful')
+                .filter(([, v]) => v.definition.getSettings().default !== undefined)
+                .map(([k, v]) => [k, v.definition.getSettings().default]));
+            return { ...defaultValues, ...statefulParameterDefaultValues };
+        });
+    }
+    get inputTransformations() {
+        return this.getFromCacheOrCreate('inputTransformations', () => {
+            if (!this.settings.parameterSettings) {
+                return {};
+            }
+            return Object.fromEntries(Object.entries(this.settings.parameterSettings)
+                .filter(([, v]) => v.inputTransformation !== undefined)
+                .map(([k, v]) => [k, v.inputTransformation]));
+        });
+    }
+    get statefulParameterOrder() {
+        return this.getFromCacheOrCreate('stateParameterOrder', () => {
+            const entries = Object.entries(this.settings.parameterSettings ?? {})
+                .filter(([, v]) => v?.type === 'stateful')
+                .map(([k, v]) => [k, v]);
+            const orderedEntries = entries.filter(([, v]) => v.order !== undefined);
+            const unorderedEntries = entries.filter(([, v]) => v.order === undefined);
+            orderedEntries.sort((a, b) => a[1].order - b[1].order);
+            const resultArray = [
+                ...orderedEntries.map(([k]) => k),
+                ...unorderedEntries.map(([k]) => k)
+            ];
+            return new Map(resultArray.map((key, idx) => [key, idx]));
+        });
+    }
+    validateSettings() {
+        // validate parameter settings
+        if (this.settings.parameterSettings) {
+            for (const [k, v] of Object.entries(this.settings.parameterSettings)) {
+                if (!v) {
+                    throw new Error(`Resource: ${this.id}. Parameter setting ${k} was left undefined`);
+                }
+                this.validateParameterEqualsFn(v, k);
+            }
+        }
+        if (this.allowMultiple
+            && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
+            throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`);
+        }
+    }
+    validateParameterEqualsFn(parameter, key) {
+        if (parameter.type === 'stateful') {
+            const nestedSettings = parameter.definition.getSettings();
+            if (nestedSettings.type === 'stateful') {
+                throw new Error(`Nested stateful parameters are not allowed for ${key}`);
+            }
+            this.validateParameterEqualsFn(nestedSettings, key);
+        }
+        // The rest of the types have defaults set already
+    }
+    resolveEqualsFn(parameter, key) {
+        if (parameter.type === 'array') {
+            return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter);
+        }
+        if (parameter.type === 'stateful') {
+            return this.resolveEqualsFn(parameter.definition.getSettings(), key);
+        }
+        return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
+    }
+    getFromCacheOrCreate(key, create) {
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const result = create();
+        this.cache.set(key, result);
+        return result;
+    }
+}

package/dist/resource/resource-controller.d.ts

@@ -0,0 +1,30 @@
+import { Ajv, ValidateFunction } from 'ajv';
+import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
+import { Resource } from './resource.js';
+import { ResourceSettings } from './resource-settings.js';
+export declare class ResourceController<T extends StringIndexedObject> {
+    readonly resource: Resource<T>;
+    readonly settings: ResourceSettings<T>;
+    readonly parsedSettings: ParsedResourceSettings<T>;
+    readonly typeId: string;
+    readonly dependencies: string[];
+    protected ajv?: Ajv;
+    protected schemaValidator?: ValidateFunction;
+    constructor(resource: Resource<T>);
+    initialize(): Promise<void>;
+    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
+    plan(desiredConfig: Partial<T> & ResourceConfig | null, stateConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
+    apply(plan: Plan<T>): Promise<void>;
+    private applyCreate;
+    private applyModify;
+    private applyDestroy;
+    private validateRefreshResults;
+    private applyTransformParameters;
+    private addDefaultValues;
+    private refreshNonStatefulParameters;
+    private refreshStatefulParameters;
+    private validatePlanInputs;
+    private getSortedStatefulParameterChanges;
+}

package/dist/resource/resource-controller.js

@@ -0,0 +1,247 @@
+import { Ajv } from 'ajv';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ConfigParser } from './config-parser.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
+export class ResourceController {
+    resource;
+    settings;
+    parsedSettings;
+    typeId;
+    dependencies;
+    ajv;
+    schemaValidator;
+    constructor(resource) {
+        this.resource = resource;
+        this.settings = resource.getSettings();
+        this.typeId = this.settings.id;
+        this.dependencies = this.settings.dependencies ?? [];
+        if (this.settings.schema) {
+            this.ajv = new Ajv({
+                allErrors: true,
+                strict: true,
+                strictRequired: false,
+            });
+            this.schemaValidator = this.ajv.compile(this.settings.schema);
+        }
+        this.parsedSettings = new ParsedResourceSettings(this.settings);
+    }
+    async initialize() {
+        return this.resource.initialize();
+    }
+    async validate(parameters, resourceMetaData) {
+        if (this.schemaValidator) {
+            const isValid = this.schemaValidator(parameters);
+            if (!isValid) {
+                return {
+                    isValid: false,
+                    resourceName: resourceMetaData.name,
+                    resourceType: resourceMetaData.type,
+                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
+                };
+            }
+        }
+        let isValid = true;
+        let customValidationErrorMessage;
+        try {
+            await this.resource.validate(parameters);
+        }
+        catch (error) {
+            isValid = false;
+            customValidationErrorMessage = error.message;
+        }
+        if (!isValid) {
+            return {
+                customValidationErrorMessage,
+                isValid: false,
+                resourceName: resourceMetaData.name,
+                resourceType: resourceMetaData.type,
+                schemaValidationErrors: this.schemaValidator?.errors ?? [],
+            };
+        }
+        return {
+            isValid: true,
+            resourceName: resourceMetaData.name,
+            resourceType: resourceMetaData.type,
+            schemaValidationErrors: [],
+        };
+    }
+    async plan(desiredConfig, stateConfig = null, statefulMode = false) {
+        this.validatePlanInputs(desiredConfig, stateConfig, statefulMode);
+        this.addDefaultValues(desiredConfig);
+        await this.applyTransformParameters(desiredConfig);
+        // Parse data from the user supplied config
+        const parsedConfig = new ConfigParser(desiredConfig, stateConfig, this.parsedSettings.statefulParameters);
+        const { coreParameters, desiredParameters, stateParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        // Refresh resource parameters. This refreshes the parameters that configure the resource itself
+        const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
+        // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
+        if (currentParametersArray === null
+            || currentParametersArray === undefined
+            || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
+            || currentParametersArray.length === 0
+            || currentParametersArray.filter(Boolean).length === 0) {
+            return Plan.calculate({
+                desiredParameters,
+                currentParametersArray,
+                stateParameters,
+                coreParameters,
+                settings: this.parsedSettings,
+                statefulMode,
+            });
+        }
+        // Refresh stateful parameters. These parameters have state external to the resource. allowMultiple
+        // does not work together with stateful parameters
+        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters);
+        return Plan.calculate({
+            desiredParameters,
+            currentParametersArray: [{ ...currentParametersArray[0], ...statefulCurrentParameters }],
+            stateParameters,
+            coreParameters,
+            settings: this.parsedSettings,
+            statefulMode
+        });
+    }
+    async apply(plan) {
+        if (plan.getResourceType() !== this.typeId) {
+            throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
+        }
+        switch (plan.changeSet.operation) {
+            case ResourceOperation.CREATE: {
+                return this.applyCreate(plan);
+            }
+            case ResourceOperation.MODIFY: {
+                return this.applyModify(plan);
+            }
+            case ResourceOperation.RECREATE: {
+                await this.applyDestroy(plan);
+                return this.applyCreate(plan);
+            }
+            case ResourceOperation.DESTROY: {
+                return this.applyDestroy(plan);
+            }
+        }
+    }
+    async applyCreate(plan) {
+        await this.resource.create(plan);
+        const statefulParameterChanges = this.getSortedStatefulParameterChanges(plan.changeSet.parameterChanges);
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.parsedSettings.statefulParameters.get(parameterChange.name);
+            await statefulParameter.add(parameterChange.newValue, plan);
+        }
+    }
+    async applyModify(plan) {
+        const parameterChanges = plan
+            .changeSet
+            .parameterChanges
+            .filter((c) => c.operation !== ParameterOperation.NOOP);
+        const statelessParameterChanges = parameterChanges
+            .filter((pc) => !this.parsedSettings.statefulParameters.has(pc.name));
+        for (const pc of statelessParameterChanges) {
+            await this.resource.modify(pc, plan);
+        }
+        const statefulParameterChanges = this.getSortedStatefulParameterChanges(plan.changeSet.parameterChanges);
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.parsedSettings.statefulParameters.get(parameterChange.name);
+            switch (parameterChange.operation) {
+                case ParameterOperation.ADD: {
+                    await statefulParameter.add(parameterChange.newValue, plan);
+                    break;
+                }
+                case ParameterOperation.MODIFY: {
+                    await statefulParameter.modify(parameterChange.newValue, parameterChange.previousValue, plan);
+                    break;
+                }
+                case ParameterOperation.REMOVE: {
+                    await statefulParameter.remove(parameterChange.previousValue, plan);
+                    break;
+                }
+            }
+        }
+    }
+    async applyDestroy(plan) {
+        // If this option is set (defaults to false), then stateful parameters need to be destroyed
+        // as well. This means that the stateful parameter wouldn't have been normally destroyed with applyDestroy()
+        if (this.settings.removeStatefulParametersBeforeDestroy) {
+            const statefulParameterChanges = this.getSortedStatefulParameterChanges(plan.changeSet.parameterChanges);
+            for (const parameterChange of statefulParameterChanges) {
+                const statefulParameter = this.parsedSettings.statefulParameters.get(parameterChange.name);
+                await statefulParameter.remove(parameterChange.previousValue, plan);
+            }
+        }
+        await this.resource.destroy(plan);
+    }
+    validateRefreshResults(refresh) {
+        if (!refresh) {
+            return;
+        }
+        if (!this.settings.allowMultiple && refresh.length > 1) {
+            throw new Error(`Resource: ${this.settings.id}. Allow multiple was set to false but multiple refresh results were returned.
+
+${JSON.stringify(refresh, null, 2)}     
+`);
+        }
+    }
+    async applyTransformParameters(desired) {
+        if (!desired) {
+            return;
+        }
+        for (const [key, inputTransformation] of Object.entries(this.parsedSettings.inputTransformations)) {
+            if (desired[key] === undefined || !inputTransformation) {
+                continue;
+            }
+            desired[key] = await inputTransformation(desired[key]);
+        }
+        if (this.settings.inputTransformation) {
+            const transformed = await this.settings.inputTransformation(desired);
+            Object.keys(desired).forEach((k) => delete desired[k]);
+            Object.assign(desired, transformed);
+        }
+    }
+    addDefaultValues(desired) {
+        if (!desired) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
+            if (defaultValue !== undefined && (desired[key] === undefined || desired[key] === null)) {
+                desired[key] = defaultValue;
+            }
+        }
+    }
+    async refreshNonStatefulParameters(resourceParameters) {
+        const result = await this.resource.refresh(resourceParameters);
+        const currentParametersArray = Array.isArray(result) || result === null
+            ? result
+            : [result];
+        this.validateRefreshResults(currentParametersArray);
+        return currentParametersArray;
+    }
+    // Refresh stateful parameters
+    // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
+    async refreshStatefulParameters(statefulParametersConfig) {
+        const result = {};
+        const sortedEntries = Object.entries(statefulParametersConfig)
+            .sort(([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1) - this.parsedSettings.statefulParameterOrder.get(key2));
+        for (const [key, desiredValue] of sortedEntries) {
+            const statefulParameter = this.parsedSettings.statefulParameters.get(key);
+            if (!statefulParameter) {
+                throw new Error(`Stateful parameter ${key} was not found`);
+            }
+            result[key] = await statefulParameter.refresh(desiredValue ?? null);
+        }
+        return result;
+    }
+    validatePlanInputs(desired, current, statefulMode) {
+        if (!desired && !current) {
+            throw new Error('Desired config and current config cannot both be missing');
+        }
+        if (!statefulMode && !desired) {
+            throw new Error('Desired config must be provided in non-stateful mode');
+        }
+    }
+    getSortedStatefulParameterChanges(parameterChanges) {
+        return parameterChanges
+            .filter((pc) => this.parsedSettings.statefulParameters.has(pc.name))
+            .sort((a, b) => this.parsedSettings.statefulParameterOrder.get(a.name) - this.parsedSettings.statefulParameterOrder.get(b.name));
+    }
+}