codify-plugin-lib 1.0.36 → 1.0.38

package/dist/entities/change-set.d.ts

@@ -1,16 +1,24 @@
-import { ParameterOperation, ResourceConfig, ResourceOperation } from 'codify-schemas';
-export interface ParameterChange {
-    name: string;
+import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { ParameterConfiguration } from './plan-types.js';
+export interface ParameterChange<T extends StringIndexedObject> {
+    name: keyof T & string;
     operation: ParameterOperation;
     previousValue: any | null;
     newValue: any | null;
 }
-export declare class ChangeSet {
+export declare class ChangeSet<T extends StringIndexedObject> {
     operation: ResourceOperation;
-    parameterChanges: Array<ParameterChange>;
-    constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange>);
-    static createForNullCurrentConfig(desiredConfig: ResourceConfig): ChangeSet;
-    static calculateParameterChangeSet(prev: ResourceConfig, next: ResourceConfig): ParameterChange[];
+    parameterChanges: Array<ParameterChange<T>>;
+    constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange<T>>);
+    get desiredParameters(): T;
+    get currentParameters(): T;
+    static newCreate<T extends {}>(desiredConfig: T): ChangeSet<StringIndexedObject>;
+    static calculateParameterChangeSet<T extends StringIndexedObject>(desired: T | null, current: T | null, options: {
+        statefulMode: boolean;
+        parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
+    }): ParameterChange<T>[];
     static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
-    static isSame(a: unknown, b: unknown): boolean;
+    static isSame(a: unknown, b: unknown, isEqual?: (a: unknown, b: unknown) => boolean): boolean;
+    private static calculateStatefulModeChangeSet;
+    private static calculateStatelessModeChangeSet;
 }

package/dist/entities/change-set.js

@@ -6,7 +6,21 @@ export class ChangeSet {
         this.operation = operation;
         this.parameterChanges = parameterChanges;
     }
-    static createForNullCurrentConfig(desiredConfig) {
+    get desiredParameters() {
+        return this.parameterChanges
+            .reduce((obj, pc) => ({
+            ...obj,
+            [pc.name]: pc.newValue,
+        }), {});
+    }
+    get currentParameters() {
+        return this.parameterChanges
+            .reduce((obj, pc) => ({
+            ...obj,
+            [pc.name]: pc.previousValue,
+        }), {});
+    }
+    static newCreate(desiredConfig) {
         const parameterChangeSet = Object.entries(desiredConfig)
             .filter(([k,]) => k !== 'type' && k !== 'name')
             .map(([k, v]) => {
@@ -19,47 +33,76 @@ export class ChangeSet {
         });
         return new ChangeSet(ResourceOperation.CREATE, parameterChangeSet);
     }
-    static calculateParameterChangeSet(prev, next) {
+    static calculateParameterChangeSet(desired, current, options) {
+        if (options.statefulMode) {
+            return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterConfigurations);
+        }
+        else {
+            return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterConfigurations);
+        }
+    }
+    static combineResourceOperations(prev, next) {
+        const orderOfOperations = [
+            ResourceOperation.NOOP,
+            ResourceOperation.MODIFY,
+            ResourceOperation.RECREATE,
+            ResourceOperation.CREATE,
+            ResourceOperation.DESTROY,
+        ];
+        const indexPrev = orderOfOperations.indexOf(prev);
+        const indexNext = orderOfOperations.indexOf(next);
+        return orderOfOperations[Math.max(indexPrev, indexNext)];
+    }
+    static isSame(a, b, isEqual) {
+        if (isEqual) {
+            return isEqual(a, b);
+        }
+        if (Array.isArray(a) && Array.isArray(b)) {
+            const sortedPrev = a.map((x) => x).sort();
+            const sortedNext = b.map((x) => x).sort();
+            return JSON.stringify(sortedPrev) === JSON.stringify(sortedNext);
+        }
+        return a === b;
+    }
+    static calculateStatefulModeChangeSet(desired, current, parameterConfigurations) {
         const parameterChangeSet = new Array();
-        const filteredPrev = Object.fromEntries(Object.entries(prev)
-            .filter(([k,]) => k !== 'type' && k !== 'name'));
-        const filteredNext = Object.fromEntries(Object.entries(next)
-            .filter(([k,]) => k !== 'type' && k !== 'name'));
-        for (const [k, v] of Object.entries(filteredPrev)) {
-            if (!filteredNext[k]) {
+        const _desired = { ...desired };
+        const _current = { ...current };
+        for (const [k, v] of Object.entries(_current)) {
+            if (_desired[k] == null) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: v,
                     newValue: null,
                     operation: ParameterOperation.REMOVE,
                 });
-                delete filteredPrev[k];
+                delete _current[k];
                 continue;
             }
-            if (!ChangeSet.isSame(filteredPrev[k], filteredNext[k])) {
+            if (!ChangeSet.isSame(_current[k], _desired[k], parameterConfigurations?.[k]?.isEqual)) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: v,
-                    newValue: filteredNext[k],
+                    newValue: _desired[k],
                     operation: ParameterOperation.MODIFY,
                 });
-                delete filteredPrev[k];
-                delete filteredNext[k];
+                delete _current[k];
+                delete _desired[k];
                 continue;
             }
             parameterChangeSet.push({
                 name: k,
                 previousValue: v,
-                newValue: filteredNext[k],
+                newValue: _desired[k],
                 operation: ParameterOperation.NOOP,
             });
-            delete filteredPrev[k];
-            delete filteredNext[k];
+            delete _current[k];
+            delete _desired[k];
         }
-        if (Object.keys(filteredPrev).length !== 0) {
+        if (Object.keys(_current).length !== 0) {
             throw Error('Diff algorithm error');
         }
-        for (const [k, v] of Object.entries(filteredNext)) {
+        for (const [k, v] of Object.entries(_desired)) {
             parameterChangeSet.push({
                 name: k,
                 previousValue: null,
@@ -69,24 +112,36 @@ export class ChangeSet {
         }
         return parameterChangeSet;
     }
-    static combineResourceOperations(prev, next) {
-        const orderOfOperations = [
-            ResourceOperation.NOOP,
-            ResourceOperation.MODIFY,
-            ResourceOperation.RECREATE,
-            ResourceOperation.CREATE,
-            ResourceOperation.DESTROY,
-        ];
-        const indexPrev = orderOfOperations.indexOf(prev);
-        const indexNext = orderOfOperations.indexOf(next);
-        return orderOfOperations[Math.max(indexPrev, indexNext)];
-    }
-    static isSame(a, b) {
-        if (Array.isArray(a) && Array.isArray(b)) {
-            const sortedPrev = a.map((x) => x).sort();
-            const sortedNext = b.map((x) => x).sort();
-            return JSON.stringify(sortedPrev) === JSON.stringify(sortedNext);
+    static calculateStatelessModeChangeSet(desired, current, parameterConfigurations) {
+        const parameterChangeSet = new Array();
+        const _desired = { ...desired };
+        const _current = { ...current };
+        for (const [k, v] of Object.entries(_desired)) {
+            if (_current[k] == null) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: null,
+                    newValue: v,
+                    operation: ParameterOperation.ADD,
+                });
+                continue;
+            }
+            if (!ChangeSet.isSame(_current[k], _desired[k], parameterConfigurations?.[k]?.isEqual)) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: _current[k],
+                    newValue: _desired[k],
+                    operation: ParameterOperation.MODIFY,
+                });
+                continue;
+            }
+            parameterChangeSet.push({
+                name: k,
+                previousValue: v,
+                newValue: v,
+                operation: ParameterOperation.NOOP,
+            });
         }
-        return a === b;
+        return parameterChangeSet;
     }
 }

package/dist/entities/plan-types.d.ts

@@ -0,0 +1,11 @@
+import { ResourceOperation } from 'codify-schemas';
+export interface ParameterConfiguration {
+    planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+    isEqual?: (a: any, b: any) => boolean;
+    isArrayElementEqual?: (a: any, b: any) => boolean;
+    isStatefulParameter?: boolean;
+}
+export interface PlanConfiguration {
+    statefulMode: boolean;
+    parameterConfigurations?: Record<string, ParameterConfiguration>;
+}

package/dist/entities/plan-types.js

@@ -0,0 +1 @@
+export {};

package/dist/entities/plan.d.ts

@@ -1,11 +1,15 @@
 import { ChangeSet } from './change-set.js';
-import { PlanResponseData, ResourceConfig } from 'codify-schemas';
-export declare class Plan<T extends ResourceConfig> {
+import { ApplyRequestData, PlanResponseData, ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { PlanConfiguration } from './plan-types.js';
+export declare class Plan<T extends StringIndexedObject> {
     id: string;
-    changeSet: ChangeSet;
-    resourceConfig: T;
-    constructor(id: string, changeSet: ChangeSet, resourceConfig: T);
-    static create<T extends ResourceConfig>(changeSet: ChangeSet, resourceConfig: T): Plan<T>;
+    changeSet: ChangeSet<T>;
+    resourceMetadata: ResourceConfig;
+    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
+    static create<T extends StringIndexedObject>(desiredConfig: Partial<T> & ResourceConfig, currentConfig: Partial<T> & ResourceConfig | null, configuration: PlanConfiguration): Plan<T>;
     getResourceType(): string;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan']): Plan<T>;
+    get desiredConfig(): T;
+    get currentConfig(): T;
     toResponse(): PlanResponseData;
 }

package/dist/entities/plan.js

@@ -1,25 +1,84 @@
+import { ChangeSet } from './change-set.js';
+import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
 import { randomUUID } from 'crypto';
+import { splitUserConfig } from '../utils/utils.js';
 export class Plan {
     id;
     changeSet;
-    resourceConfig;
-    constructor(id, changeSet, resourceConfig) {
+    resourceMetadata;
+    constructor(id, changeSet, resourceMetadata) {
         this.id = id;
         this.changeSet = changeSet;
-        this.resourceConfig = resourceConfig;
+        this.resourceMetadata = resourceMetadata;
     }
-    static create(changeSet, resourceConfig) {
-        return new Plan(randomUUID(), changeSet, resourceConfig);
+    static create(desiredConfig, currentConfig, configuration) {
+        const parameterConfigurations = configuration.parameterConfigurations ?? {};
+        const statefulParameterNames = new Set([...Object.entries(parameterConfigurations)]
+            .filter(([k, v]) => v.isStatefulParameter)
+            .map(([k, v]) => k));
+        const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
+        const { parameters: currentParameters } = currentConfig ? splitUserConfig(currentConfig) : { parameters: {} };
+        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: configuration.statefulMode, parameterConfigurations });
+        let resourceOperation;
+        if (!currentConfig && desiredConfig) {
+            resourceOperation = ResourceOperation.CREATE;
+        }
+        else if (currentConfig && !desiredConfig) {
+            resourceOperation = ResourceOperation.DESTROY;
+        }
+        else {
+            resourceOperation = parameterChangeSet
+                .filter((change) => change.operation !== ParameterOperation.NOOP)
+                .reduce((operation, curr) => {
+                let newOperation;
+                if (statefulParameterNames.has(curr.name)) {
+                    newOperation = ResourceOperation.MODIFY;
+                }
+                else if (parameterConfigurations[curr.name]?.planOperation) {
+                    newOperation = parameterConfigurations[curr.name].planOperation;
+                }
+                else {
+                    newOperation = ResourceOperation.RECREATE;
+                }
+                return ChangeSet.combineResourceOperations(operation, newOperation);
+            }, ResourceOperation.NOOP);
+        }
+        return new Plan(randomUUID(), new ChangeSet(resourceOperation, parameterChangeSet), resourceMetadata);
     }
     getResourceType() {
-        return this.resourceConfig.type;
+        return this.resourceMetadata.type;
+    }
+    static fromResponse(data) {
+        if (!data) {
+            throw new Error('Data is empty');
+        }
+        return new Plan(randomUUID(), new ChangeSet(data.operation, data.parameters.map(value => ({
+            ...value,
+            previousValue: null,
+        }))), {
+            type: data.resourceType,
+            name: data.resourceName,
+            ...(data.parameters.reduce((prev, { name, newValue }) => Object.assign(prev, { [name]: newValue }), {}))
+        });
+    }
+    get desiredConfig() {
+        return {
+            ...this.resourceMetadata,
+            ...this.changeSet.desiredParameters,
+        };
+    }
+    get currentConfig() {
+        return {
+            ...this.resourceMetadata,
+            ...this.changeSet.currentParameters,
+        };
     }
     toResponse() {
         return {
             planId: this.id,
             operation: this.changeSet.operation,
-            resourceName: this.resourceConfig.name,
-            resourceType: this.resourceConfig.type,
+            resourceName: this.resourceMetadata.name,
+            resourceType: this.resourceMetadata.type,
             parameters: this.changeSet.parameterChanges,
         };
     }

package/dist/entities/plugin.d.ts

@@ -9,5 +9,6 @@ export declare class Plugin {
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;
     plan(data: PlanRequestData): Promise<PlanResponseData>;
     apply(data: ApplyRequestData): Promise<void>;
+    private resolvePlan;
     protected crossValidateResources(configs: ResourceConfig[]): Promise<void>;
 }

package/dist/entities/plugin.js

@@ -1,3 +1,4 @@
+import { Plan } from './plan.js';
 export class Plugin {
     resources;
     planStorage;
@@ -12,26 +13,27 @@ export class Plugin {
         return {
             resourceDefinitions: [...this.resources.values()]
                 .map((r) => ({
-                type: r.getTypeId(),
+                type: r.typeId,
                 dependencies: r.getDependencyTypeIds(),
             }))
         };
     }
     async validate(data) {
-        const totalErrors = [];
+        const validationResults = [];
         for (const config of data.configs) {
             if (!this.resources.has(config.type)) {
                 throw new Error(`Resource type not found: ${config.type}`);
             }
-            const error = await this.resources.get(config.type).validate(config);
-            if (error) {
-                totalErrors.push(...error);
-            }
+            const validateResult = await this.resources.get(config.type).validate(config);
+            validationResults.push({
+                ...validateResult,
+                resourceType: config.type,
+                resourceName: config.name,
+            });
         }
         await this.crossValidateResources(data.configs);
         return {
-            isValid: true,
-            errors: totalErrors,
+            validationResults
         };
     }
     async plan(data) {
@@ -43,16 +45,25 @@ export class Plugin {
         return plan.toResponse();
     }
     async apply(data) {
-        const { planId } = data;
-        const plan = this.planStorage.get(planId);
-        if (!plan) {
-            throw new Error(`Plan with id: ${planId} was not found`);
+        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.resources.get(plan.getResourceType());
         if (!resource) {
             throw new Error('Malformed plan with resource that cannot be found');
         }
         await resource.apply(plan);
     }
+    resolvePlan(data) {
+        const { planId, plan: planRequest } = data;
+        if (planId) {
+            if (!this.planStorage.has(planId)) {
+                throw new Error(`Plan with id: ${planId} was not found`);
+            }
+            return this.planStorage.get(planId);
+        }
+        return Plan.fromResponse(data.plan);
+    }
     async crossValidateResources(configs) { }
 }

package/dist/entities/resource-types.d.ts

@@ -0,0 +1,24 @@
+import { StatefulParameter } from './stateful-parameter.js';
+import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { Resource } from './resource.js';
+export type ErrorMessage = string;
+export interface ResourceParameterConfiguration {
+    planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+    isEqual?: (a: any, b: any) => boolean;
+}
+export interface ResourceConfiguration<T extends StringIndexedObject> {
+    type: string;
+    callStatefulParameterRemoveOnDestroy?: boolean;
+    dependencies?: Resource<any>[];
+    statefulParameters?: Array<StatefulParameter<T, T[keyof T]>>;
+    parameterConfigurations?: Partial<Record<keyof T, ResourceParameterConfiguration>>;
+}
+export interface ResourceDefinition {
+    [x: string]: {
+        type: string;
+    };
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors?: unknown[];
+}

package/dist/entities/resource-types.js

@@ -0,0 +1 @@
+export {};

package/dist/entities/resource.d.ts

@@ -1,23 +1,28 @@
-import { ResourceConfig, ResourceOperation } from 'codify-schemas';
-import { ParameterChange } from './change-set.js';
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
-export type ErrorMessage = string;
-export declare abstract class Resource<T extends ResourceConfig> {
-    private dependencies;
-    private statefulParameters;
-    constructor(dependencies?: Resource<any>[]);
-    abstract getTypeId(): string;
+import { ResourceConfiguration, ValidationResult } from './resource-types.js';
+import { ParameterConfiguration } from './plan-types.js';
+export declare abstract class Resource<T extends StringIndexedObject> {
+    readonly typeId: string;
+    readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+    readonly dependencies: Resource<any>[];
+    readonly parameterConfigurations: Record<string, ParameterConfiguration>;
+    private readonly options;
+    protected constructor(configuration: ResourceConfiguration<T>);
     getDependencyTypeIds(): string[];
     onInitialize(): Promise<void>;
-    plan(desiredConfig: T): Promise<Plan<T>>;
+    plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
-    protected registerStatefulParameter(parameter: StatefulParameter<T, keyof T>): void;
-    abstract validate(config: unknown): Promise<ErrorMessage[] | undefined>;
-    abstract getCurrentConfig(desiredConfig: T): Promise<T | null>;
-    abstract calculateOperation(change: ParameterChange): ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+    private _applyCreate;
+    private _applyModify;
+    private _applyDestroy;
+    private generateParameterConfigurations;
+    private validateResourceConfiguration;
+    private validateRefreshResults;
+    abstract validate(config: unknown): Promise<ValidationResult>;
+    abstract refresh(keys: Set<keyof T>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: Plan<T>): Promise<void>;
-    abstract applyModify(plan: Plan<T>): Promise<void>;
-    abstract applyRecreate(plan: Plan<T>): Promise<void>;
+    applyModify(parameterName: keyof T, newValue: unknown, previousValue: unknown, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     abstract applyDestroy(plan: Plan<T>): Promise<void>;
 }