codify-plugin-lib 1.0.37 → 1.0.39

package/dist/entities/resource.js

@@ -1,87 +1,162 @@
-import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { ChangeSet } from './change-set.js';
+import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
 import { Plan } from './plan.js';
+import { setsEqual, splitUserConfig } from '../utils/utils.js';
 export class Resource {
+    typeId;
+    statefulParameters;
     dependencies;
-    statefulParameters = new Map();
-    constructor(dependencies = []) {
-        this.dependencies = dependencies;
+    parameterConfigurations;
+    options;
+    constructor(configuration) {
+        this.validateResourceConfiguration(configuration);
+        this.typeId = configuration.type;
+        this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
+        this.parameterConfigurations = this.generateParameterConfigurations(configuration);
+        this.dependencies = configuration.dependencies ?? [];
+        this.options = configuration;
     }
     getDependencyTypeIds() {
-        return this.dependencies.map((d) => d.getTypeId());
+        return this.dependencies.map((d) => d.typeId);
     }
     async onInitialize() { }
     async plan(desiredConfig) {
-        const currentConfig = await this.getCurrentConfig(desiredConfig);
-        if (!currentConfig) {
-            return Plan.create(ChangeSet.createForNullCurrentConfig(desiredConfig), desiredConfig);
+        const planConfiguration = {
+            statefulMode: false,
+            parameterConfigurations: this.parameterConfigurations,
+        };
+        const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
+        const resourceParameters = Object.fromEntries([
+            ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
+        ]);
+        const statefulParameters = [...this.statefulParameters.values()]
+            .filter((sp) => desiredParameters[sp.name] !== undefined);
+        const keysToRefresh = new Set(Object.keys(resourceParameters));
+        const currentParameters = await this.refresh(keysToRefresh);
+        if (currentParameters == null && statefulParameters.length === 0) {
+            return Plan.create(desiredConfig, null, planConfiguration);
         }
-        const desiredConfigStatefulParameters = [...this.statefulParameters.values()]
-            .filter((sp) => desiredConfig[sp.name] !== undefined);
-        for (const statefulParameter of desiredConfigStatefulParameters) {
-            const parameterCurrentStatus = await statefulParameter.getCurrent(desiredConfig[statefulParameter.name]);
-            if (parameterCurrentStatus) {
-                currentConfig[statefulParameter.name] = parameterCurrentStatus;
+        this.validateRefreshResults(currentParameters, keysToRefresh);
+        const currentStatefulParameters = {};
+        for (const statefulParameter of statefulParameters) {
+            const desiredValue = desiredParameters[statefulParameter.name];
+            let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
+            if (Array.isArray(currentValue) && Array.isArray(desiredValue) && !planConfiguration.statefulMode) {
+                currentValue = currentValue.filter((p) => desiredValue?.includes(p));
             }
+            currentStatefulParameters[statefulParameter.name] = currentValue;
         }
-        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(currentConfig, desiredConfig);
-        const resourceOperation = parameterChangeSet
-            .filter((change) => change.operation !== ParameterOperation.NOOP)
-            .reduce((operation, curr) => {
-            const newOperation = !this.statefulParameters.has(curr.name)
-                ? this.calculateOperation(curr)
-                : ResourceOperation.MODIFY;
-            return ChangeSet.combineResourceOperations(operation, newOperation);
-        }, ResourceOperation.NOOP);
-        return Plan.create(new ChangeSet(resourceOperation, parameterChangeSet), desiredConfig);
+        return Plan.create(desiredConfig, { ...currentParameters, ...currentStatefulParameters, ...resourceMetadata }, planConfiguration);
     }
     async apply(plan) {
-        if (plan.getResourceType() !== this.getTypeId()) {
-            throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.getTypeId()} but got: ${plan.getResourceType()}`);
+        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: {
-                const parameterChanges = plan.changeSet.parameterChanges
-                    .filter((c) => c.operation !== ParameterOperation.NOOP);
-                const statelessParameterChanges = parameterChanges.filter((pc) => !this.statefulParameters.has(pc.name));
-                if (statelessParameterChanges.length > 0) {
-                    await this.applyModify(plan);
+                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.applyCreate(plan);
+        const statefulParameterChanges = plan.changeSet.parameterChanges
+            .filter((pc) => this.statefulParameters.has(pc.name));
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.statefulParameters.get(parameterChange.name);
+            await statefulParameter.applyAdd(parameterChange.newValue, plan);
+        }
+    }
+    async _applyModify(plan) {
+        const parameterChanges = plan
+            .changeSet
+            .parameterChanges
+            .filter((c) => c.operation !== ParameterOperation.NOOP);
+        const statelessParameterChanges = parameterChanges
+            .filter((pc) => !this.statefulParameters.has(pc.name));
+        for (const pc of statelessParameterChanges) {
+            await this.applyModify(pc.name, pc.newValue, pc.previousValue, false, plan);
+        }
+        const statefulParameterChanges = parameterChanges
+            .filter((pc) => this.statefulParameters.has(pc.name));
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.statefulParameters.get(parameterChange.name);
+            switch (parameterChange.operation) {
+                case ParameterOperation.ADD: {
+                    await statefulParameter.applyAdd(parameterChange.newValue, plan);
+                    break;
                 }
-                const statefulParameterChanges = parameterChanges.filter((pc) => this.statefulParameters.has(pc.name));
-                for (const parameterChange of statefulParameterChanges) {
-                    const statefulParameter = this.statefulParameters.get(parameterChange.name);
-                    switch (parameterChange.operation) {
-                        case ParameterOperation.ADD: {
-                            await statefulParameter.applyAdd(parameterChange, plan);
-                            break;
-                        }
-                        case ParameterOperation.MODIFY: {
-                            await statefulParameter.applyModify(parameterChange, plan);
-                            break;
-                        }
-                        case ParameterOperation.REMOVE: {
-                            await statefulParameter.applyRemove(parameterChange, plan);
-                            break;
-                        }
-                    }
+                case ParameterOperation.MODIFY: {
+                    await statefulParameter.applyModify(parameterChange.newValue, parameterChange.previousValue, false, plan);
+                    break;
+                }
+                case ParameterOperation.REMOVE: {
+                    await statefulParameter.applyRemove(parameterChange.previousValue, plan);
+                    break;
                 }
-                return;
             }
-            case ResourceOperation.CREATE: {
-                await this.applyCreate(plan);
-                const statefulParameterChanges = plan.changeSet.parameterChanges
-                    .filter((pc) => this.statefulParameters.has(pc.name));
-                for (const parameterChange of statefulParameterChanges) {
-                    const statefulParameter = this.statefulParameters.get(parameterChange.name);
-                    await statefulParameter.applyAdd(parameterChange, plan);
+        }
+    }
+    async _applyDestroy(plan) {
+        if (this.options.callStatefulParameterRemoveOnDestroy) {
+            const statefulParameterChanges = plan.changeSet.parameterChanges
+                .filter((pc) => this.statefulParameters.has(pc.name));
+            for (const parameterChange of statefulParameterChanges) {
+                const statefulParameter = this.statefulParameters.get(parameterChange.name);
+                await statefulParameter.applyRemove(parameterChange.previousValue, plan);
+            }
+        }
+        await this.applyDestroy(plan);
+    }
+    generateParameterConfigurations(resourceConfiguration) {
+        const resourceParameters = Object.fromEntries(Object.entries(resourceConfiguration.parameterConfigurations ?? {})
+            ?.map(([name, value]) => ([name, { ...value, isStatefulParameter: false }])));
+        const statefulParameters = resourceConfiguration.statefulParameters
+            ?.reduce((obj, sp) => {
+            return {
+                ...obj,
+                [sp.name]: {
+                    ...sp.configuration,
+                    isStatefulParameter: true,
                 }
-                return;
+            };
+        }, {}) ?? {};
+        return {
+            ...resourceParameters,
+            ...statefulParameters,
+        };
+    }
+    validateResourceConfiguration(data) {
+        if (data.parameterConfigurations && data.statefulParameters) {
+            const parameters = [...Object.keys(data.parameterConfigurations)];
+            const statefulParameterSet = new Set(Object.keys(data.statefulParameters));
+            const intersection = parameters.some((p) => statefulParameterSet.has(p));
+            if (intersection) {
+                throw new Error(`Resource ${this.typeId} cannot declare a parameter as both stateful and non-stateful`);
             }
-            case ResourceOperation.RECREATE: return this.applyRecreate(plan);
-            case ResourceOperation.DESTROY: return this.applyDestroy(plan);
         }
     }
-    registerStatefulParameter(parameter) {
-        this.statefulParameters.set(parameter.name, parameter);
+    validateRefreshResults(refresh, desiredKeys) {
+        if (!refresh) {
+            return;
+        }
+        const refreshKeys = new Set(Object.keys(refresh));
+        if (!setsEqual(desiredKeys, refreshKeys)) {
+            throw new Error(`Resource ${this.options.type}
+refresh() must return back exactly the keys that were provided
+Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
+Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
+        }
     }
+    async applyModify(parameterName, newValue, previousValue, allowDeletes, plan) { }
+    ;
 }

package/dist/entities/stateful-parameter.d.ts

@@ -1,10 +1,24 @@
-import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
-import { ResourceConfig } from 'codify-schemas';
-export declare abstract class StatefulParameter<T extends ResourceConfig, K extends keyof T> {
-    abstract get name(): K;
-    abstract getCurrent(desiredValue: T[K]): Promise<T[K]>;
-    abstract applyAdd(parameterChange: ParameterChange, plan: Plan<T>): Promise<void>;
-    abstract applyModify(parameterChange: ParameterChange, plan: Plan<T>): Promise<void>;
-    abstract applyRemove(parameterChange: ParameterChange, plan: Plan<T>): Promise<void>;
+import { StringIndexedObject } from 'codify-schemas';
+export interface StatefulParameterConfiguration<T> {
+    name: keyof T;
+    isEqual?: (a: any, b: any) => boolean;
+}
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    readonly name: keyof T;
+    readonly configuration: StatefulParameterConfiguration<T>;
+    protected constructor(configuration: StatefulParameterConfiguration<T>);
+    abstract refresh(previousValue: V | null): Promise<V | null>;
+    abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    protected constructor(configuration: StatefulParameterConfiguration<T>);
+    applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    abstract refresh(previousValue: V[] | null): Promise<V[] | null>;
+    abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
+    abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
 }

package/dist/entities/stateful-parameter.js

@@ -1,2 +1,35 @@
 export class StatefulParameter {
+    name;
+    configuration;
+    constructor(configuration) {
+        this.name = configuration.name;
+        this.configuration = configuration;
+    }
+}
+export class ArrayStatefulParameter extends StatefulParameter {
+    constructor(configuration) {
+        super(configuration);
+    }
+    async applyAdd(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.applyAddItem(value, plan);
+        }
+    }
+    async applyModify(newValues, previousValues, allowDeletes, plan) {
+        const valuesToAdd = newValues.filter((n) => !previousValues.includes(n));
+        const valuesToRemove = previousValues.filter((n) => !newValues.includes(n));
+        for (const value of valuesToAdd) {
+            await this.applyAddItem(value, plan);
+        }
+        if (allowDeletes) {
+            for (const value of valuesToRemove) {
+                await this.applyRemoveItem(value, plan);
+            }
+        }
+    }
+    async applyRemove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.applyRemoveItem(value, plan);
+        }
+    }
 }

package/dist/entities/test.d.ts

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

package/dist/entities/test.js

@@ -0,0 +1,22 @@
+import { Resource } from './resource.js';
+class Test extends Resource {
+    validate(config) {
+        throw new Error('Method not implemented.');
+    }
+    async refresh(keys) {
+        const result = {};
+        if (keys.has('propA')) {
+            result['propA'] = 'abc';
+        }
+        return result;
+    }
+    applyCreate(plan) {
+        throw new Error('Method not implemented.');
+    }
+    applyModify(parameterName, newValue, previousValue, plan) {
+        throw new Error('Method not implemented.');
+    }
+    applyDestroy(plan) {
+        throw new Error('Method not implemented.');
+    }
+}

package/dist/index.d.ts

@@ -1,9 +1,12 @@
 import { Plugin } from './entities/plugin.js';
 export * from './entities/resource.js';
+export * from './entities/resource-types.js';
 export * from './entities/plugin.js';
 export * from './entities/change-set.js';
 export * from './entities/plan.js';
+export * from './entities/plan-types.js';
 export * from './entities/stateful-parameter.js';
 export * from './utils/test-utils.js';
 export * from './utils/utils.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;
+export { ErrorMessage } from './entities/resource-types.js';

package/dist/index.js

@@ -1,8 +1,10 @@
 import { MessageHandler } from './messages/handlers.js';
 export * from './entities/resource.js';
+export * from './entities/resource-types.js';
 export * from './entities/plugin.js';
 export * from './entities/change-set.js';
 export * from './entities/plan.js';
+export * from './entities/plan-types.js';
 export * from './entities/stateful-parameter.js';
 export * from './utils/test-utils.js';
 export * from './utils/utils.js';

package/dist/utils/common-types.d.ts

@@ -0,0 +1,3 @@
+export interface StringIndexedObject {
+    [x: string]: unknown;
+}

package/dist/utils/common-types.js

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

package/dist/utils/utils.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { SpawnOptions } from 'child_process';
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 export declare enum SpawnStatus {
     SUCCESS = "success",
     ERROR = "error"
@@ -16,4 +17,9 @@ export declare function codifySpawn(cmd: string, args?: string[], opts?: Omit<Co
     throws?: boolean;
 }, extras?: Record<any, any>): Promise<SpawnResult>;
 export declare function isDebug(): boolean;
+export declare function splitUserConfig<T extends StringIndexedObject>(config: T & ResourceConfig): {
+    parameters: T;
+    resourceMetadata: ResourceConfig;
+};
+export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
 export {};

package/dist/utils/utils.js

@@ -36,3 +36,18 @@ export async function codifySpawn(cmd, args, opts, extras) {
 export function isDebug() {
     return process.env.DEBUG != null && process.env.DEBUG.includes('codify');
 }
+export function splitUserConfig(config) {
+    const resourceMetadata = {
+        type: config.type,
+        ...(config.name && { name: config.name }),
+        ...(config.dependsOn && { dependsOn: config.dependsOn }),
+    };
+    const { type, name, dependsOn, ...parameters } = config;
+    return {
+        parameters: parameters,
+        resourceMetadata,
+    };
+}
+export function setsEqual(set1, set2) {
+    return set1.size === set2.size && [...set1].every((v) => set2.has(v));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.30",
+    "codify-schemas": "1.0.32",
     "@npmcli/promise-spawn": "^7.0.1"
   },
   "devDependencies": {

package/src/entities/change-set.test.ts

@@ -1,107 +1,95 @@
-import { ChangeSet } from './change-set';
+import { ChangeSet } from './change-set.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
-describe('Change set tests', () => {
+describe('Change set tests (stateful)', () => {
   it ('Correctly diffs two resource configs (modify)', () => {
-    const before = {
-      type: 'config',
+    const after = {
       propA: 'before',
       propB: 'before'
     }
 
-    const after = {
-      type: 'config',
+    const before = {
       propA: 'after',
       propB: 'after'
     }
 
-    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
     expect(cs.length).to.eq(2);
     expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs[1].operation).to.eq(ParameterOperation.MODIFY);
   })
 
   it ('Correctly diffs two resource configs (add)', () => {
-    const before = {
-      type: 'config',
+    const after = {
       propA: 'before',
+      propB: 'after'
     }
 
-    const after = {
-      type: 'config',
+    const before = {
       propA: 'after',
-      propB: 'after'
     }
 
-    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
     expect(cs.length).to.eq(2);
     expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs[1].operation).to.eq(ParameterOperation.ADD);
   })
 
   it ('Correctly diffs two resource configs (remove)', () => {
+    const after = {
+      propA: 'after',
+    }
+
     const before = {
-      type: 'config',
       propA: 'before',
       propB: 'before'
     }
 
-    const after = {
-      type: 'config',
-      propA: 'after',
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
     expect(cs.length).to.eq(2);
     expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs[1].operation).to.eq(ParameterOperation.REMOVE);
   })
 
   it ('Correctly diffs two resource configs (no-op)', () => {
-    const before = {
-      type: 'config',
+    const after = {
       propA: 'prop',
     }
 
-    const after = {
-      type: 'config',
+    const before = {
       propA: 'prop',
     }
 
-    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
     expect(cs.length).to.eq(1);
     expect(cs[0].operation).to.eq(ParameterOperation.NOOP);
   })
 
   it ('handles simple arrays', () => {
     const before = {
-      type: 'config',
       propA: ['a', 'b', 'c'],
     }
 
     const after = {
-      type: 'config',
       propA: ['b', 'a', 'c'],
     }
 
-    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
     expect(cs.length).to.eq(1);
     expect(cs[0].operation).to.eq(ParameterOperation.NOOP);
   })
 
   it ('handles simple arrays', () => {
-    const before = {
-      type: 'config',
-      propA: ['a', 'b'],
+    const after = {
+      propA: ['a', 'b', 'c'],
     }
 
-    const after = {
-      type: 'config',
-      propA: ['b', 'a', 'c'],
+    const before = {
+      propA: ['b', 'a'],
     }
 
-    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
     expect(cs.length).to.eq(1);
     expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
   })