codify-plugin-lib 1.0.176 → 1.0.178

package/dist/entities/plan.js

@@ -1,127 +0,0 @@
-import { ChangeSet } from './change-set.js';
-import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
-import { randomUUID } from 'crypto';
-export class Plan {
-    id;
-    changeSet;
-    resourceMetadata;
-    constructor(id, changeSet, resourceMetadata) {
-        this.id = id;
-        this.changeSet = changeSet;
-        this.resourceMetadata = resourceMetadata;
-    }
-    static create(desiredParameters, currentParameters, resourceMetadata, options) {
-        const parameterOptions = options.parameterOptions ?? {};
-        const statefulParameterNames = new Set([...Object.entries(parameterOptions)]
-            .filter(([k, v]) => v.isStatefulParameter)
-            .map(([k, v]) => k));
-        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: options.statefulMode, parameterOptions });
-        let resourceOperation;
-        if (!currentParameters && desiredParameters) {
-            resourceOperation = ResourceOperation.CREATE;
-        }
-        else if (currentParameters && !desiredParameters) {
-            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 (parameterOptions[curr.name]?.modifyOnChange) {
-                    newOperation = parameterOptions[curr.name].modifyOnChange ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
-                }
-                else {
-                    newOperation = ResourceOperation.RECREATE;
-                }
-                return ChangeSet.combineResourceOperations(operation, newOperation);
-            }, ResourceOperation.NOOP);
-        }
-        return new Plan(randomUUID(), new ChangeSet(resourceOperation, parameterChangeSet), resourceMetadata);
-    }
-    getResourceType() {
-        return this.resourceMetadata.type;
-    }
-    static fromResponse(data, defaultValues) {
-        if (!data) {
-            throw new Error('Data is empty');
-        }
-        addDefaultValues();
-        return new Plan(randomUUID(), new ChangeSet(data.operation, data.parameters), {
-            type: data.resourceType,
-            name: data.resourceName,
-        });
-        function addDefaultValues() {
-            Object.entries(defaultValues ?? {})
-                .forEach(([key, defaultValue]) => {
-                const configValueExists = data
-                    .parameters
-                    .some((p) => p.name === key);
-                if (configValueExists) {
-                    return;
-                }
-                switch (data.operation) {
-                    case ResourceOperation.CREATE: {
-                        data.parameters.push({
-                            name: key,
-                            operation: ParameterOperation.ADD,
-                            previousValue: null,
-                            newValue: defaultValue,
-                        });
-                        break;
-                    }
-                    case ResourceOperation.DESTROY: {
-                        data.parameters.push({
-                            name: key,
-                            operation: ParameterOperation.REMOVE,
-                            previousValue: defaultValue,
-                            newValue: null,
-                        });
-                        break;
-                    }
-                    case ResourceOperation.MODIFY:
-                    case ResourceOperation.RECREATE:
-                    case ResourceOperation.NOOP: {
-                        data.parameters.push({
-                            name: key,
-                            operation: ParameterOperation.NOOP,
-                            previousValue: defaultValue,
-                            newValue: defaultValue,
-                        });
-                        break;
-                    }
-                }
-            });
-        }
-    }
-    get desiredConfig() {
-        if (this.changeSet.operation === ResourceOperation.DESTROY) {
-            return null;
-        }
-        return {
-            ...this.resourceMetadata,
-            ...this.changeSet.desiredParameters,
-        };
-    }
-    get currentConfig() {
-        if (this.changeSet.operation === ResourceOperation.CREATE) {
-            return null;
-        }
-        return {
-            ...this.resourceMetadata,
-            ...this.changeSet.currentParameters,
-        };
-    }
-    toResponse() {
-        return {
-            planId: this.id,
-            operation: this.changeSet.operation,
-            resourceName: this.resourceMetadata.name,
-            resourceType: this.resourceMetadata.type,
-            parameters: this.changeSet.parameterChanges,
-        };
-    }
-}

package/dist/entities/plugin.d.ts

@@ -1,16 +0,0 @@
-import { ApplyRequestData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
-import { Plan } from './plan.js';
-import { Resource } from './resource.js';
-export declare class Plugin {
-    name: string;
-    resources: Map<string, Resource<ResourceConfig>>;
-    planStorage: Map<string, Plan<any>>;
-    static create(name: string, resources: Resource<any>[]): Plugin;
-    constructor(name: string, resources: Map<string, Resource<ResourceConfig>>);
-    initialize(): Promise<InitializeResponseData>;
-    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,80 +0,0 @@
-import { splitUserConfig } from '../utils/utils.js';
-import { Plan } from './plan.js';
-export class Plugin {
-    name;
-    resources;
-    planStorage;
-    static create(name, resources) {
-        const resourceMap = new Map(resources.map((r) => [r.typeId, r]));
-        return new Plugin(name, resourceMap);
-    }
-    constructor(name, resources) {
-        this.name = name;
-        this.resources = resources;
-        this.planStorage = new Map();
-    }
-    async initialize() {
-        for (const resource of this.resources.values()) {
-            await resource.onInitialize();
-        }
-        return {
-            resourceDefinitions: [...this.resources.values()]
-                .map((r) => ({
-                dependencies: r.dependencies,
-                type: r.typeId,
-            }))
-        };
-    }
-    async validate(data) {
-        const validationResults = [];
-        for (const config of data.configs) {
-            if (!this.resources.has(config.type)) {
-                throw new Error(`Resource type not found: ${config.type}`);
-            }
-            const { parameters, resourceMetadata } = splitUserConfig(config);
-            const validation = await this.resources
-                .get(config.type)
-                .validate(parameters, resourceMetadata);
-            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.resources.has(type)) {
-            throw new Error(`Resource type not found: ${type}`);
-        }
-        const plan = await this.resources.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.resources.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.resources.has(planRequest.resourceType)) {
-            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
-        }
-        const resource = this.resources.get(planRequest.resourceType);
-        return Plan.fromResponse(planRequest, resource.defaultValues);
-    }
-    async crossValidateResources(configs) { }
-}

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

@@ -1,31 +0,0 @@
-import { StringIndexedObject } from 'codify-schemas';
-import { ParameterOptions } from './plan-types.js';
-import { ResourceParameterOptions } from './resource-types.js';
-import { StatefulParameter } from './stateful-parameter.js';
-import { TransformParameter } from './transform-parameter.js';
-export interface ResourceOptions<T extends StringIndexedObject> {
-    callStatefulParameterRemoveOnDestroy?: boolean;
-    dependencies?: string[];
-    parameterOptions?: Partial<Record<keyof T, ResourceParameterOptions | ResourceStatefulParameterOptions<T> | ResourceTransformParameterOptions<T>>>;
-    schema?: unknown;
-    type: string;
-}
-export interface ResourceStatefulParameterOptions<T extends StringIndexedObject> {
-    order?: number;
-    statefulParameter: StatefulParameter<T, T[keyof T]>;
-}
-export interface ResourceTransformParameterOptions<T extends StringIndexedObject> {
-    order?: number;
-    transformParameter: TransformParameter<T>;
-}
-export declare class ResourceOptionsParser<T extends StringIndexedObject> {
-    private options;
-    constructor(options: ResourceOptions<T>);
-    get statefulParameters(): Map<keyof T, StatefulParameter<T, T[keyof T]>>;
-    get transformParameters(): Map<keyof T, TransformParameter<T>>;
-    get resourceParameters(): Map<keyof T, ResourceParameterOptions>;
-    get changeSetParameterOptions(): Record<keyof T, ParameterOptions>;
-    get defaultValues(): Partial<Record<keyof T, unknown>>;
-    get statefulParameterOrder(): Map<keyof T, number>;
-    get transformParameterOrder(): Map<keyof T, number>;
-}

package/dist/entities/resource-options.js

@@ -1,76 +0,0 @@
-export class ResourceOptionsParser {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    get statefulParameters() {
-        const statefulParameters = Object.entries(this.options.parameterOptions ?? {})
-            .filter(([, p]) => p?.hasOwnProperty('statefulParameter'))
-            .map(([k, v]) => [k, v])
-            .map(([k, v]) => [k, v.statefulParameter]);
-        return new Map(statefulParameters);
-    }
-    get transformParameters() {
-        const transformParameters = Object.entries(this.options.parameterOptions ?? {})
-            .filter(([, p]) => p?.hasOwnProperty('transformParameter'))
-            .map(([k, v]) => [k, v])
-            .map(([k, v]) => [k, v.transformParameter]);
-        return new Map(transformParameters);
-    }
-    get resourceParameters() {
-        const resourceParameters = Object.entries(this.options.parameterOptions ?? {})
-            .filter(([, p]) => !(p?.hasOwnProperty('statefulParameter') || p?.hasOwnProperty('transformParameter')))
-            .map(([k, v]) => [k, v]);
-        return new Map(resourceParameters);
-    }
-    get changeSetParameterOptions() {
-        const resourceParameters = Object.fromEntries([...this.resourceParameters.entries()]
-            .map(([name, value]) => ([name, { ...value, isStatefulParameter: false }])));
-        const statefulParameters = [...this.statefulParameters.entries()]
-            ?.reduce((obj, sp) => ({
-            ...obj,
-            [sp[0]]: {
-                ...sp[1].options,
-                isStatefulParameter: true,
-            }
-        }), {});
-        return {
-            ...resourceParameters,
-            ...statefulParameters,
-        };
-    }
-    get defaultValues() {
-        if (!this.options.parameterOptions) {
-            return {};
-        }
-        return Object.fromEntries([...this.resourceParameters.entries()]
-            .filter(([, rp]) => rp.default !== undefined)
-            .map(([name, rp]) => [name, rp.default]));
-    }
-    get statefulParameterOrder() {
-        const entries = Object.entries(this.options.parameterOptions ?? {})
-            .filter(([, v]) => v?.hasOwnProperty('statefulParameter'))
-            .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]));
-    }
-    get transformParameterOrder() {
-        const entries = Object.entries(this.options.parameterOptions ?? {})
-            .filter(([, v]) => v?.hasOwnProperty('transformParameter'))
-            .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]));
-    }
-}

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

@@ -1,11 +0,0 @@
-export type ErrorMessage = string;
-export interface ResourceParameterOptions {
-    default?: unknown;
-    isEqual?: (desired: any, current: any) => boolean;
-    modifyOnChange?: boolean;
-}
-export interface ResourceDefinition {
-    [x: string]: {
-        type: string;
-    };
-}

package/dist/entities/resource-types.js

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

package/dist/entities/resource.d.ts

@@ -1,42 +0,0 @@
-import { Ajv, ValidateFunction } from 'ajv';
-import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
-import { ParameterChange } from './change-set.js';
-import { Plan } from './plan.js';
-import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions } from './plan-types.js';
-import { ResourceOptions } from './resource-options.js';
-import { ResourceParameterOptions } from './resource-types.js';
-import { StatefulParameter } from './stateful-parameter.js';
-import { TransformParameter } from './transform-parameter.js';
-export declare abstract class Resource<T extends StringIndexedObject> {
-    readonly typeId: string;
-    readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
-    readonly transformParameters: Map<keyof T, TransformParameter<T>>;
-    readonly resourceParameters: Map<keyof T, ResourceParameterOptions>;
-    readonly statefulParameterOrder: Map<keyof T, number>;
-    readonly transformParameterOrder: Map<keyof T, number>;
-    readonly dependencies: string[];
-    readonly parameterOptions: Record<keyof T, ParameterOptions>;
-    readonly options: ResourceOptions<T>;
-    readonly defaultValues: Partial<Record<keyof T, unknown>>;
-    protected ajv?: Ajv;
-    protected schemaValidator?: ValidateFunction;
-    protected constructor(options: ResourceOptions<T>);
-    onInitialize(): Promise<void>;
-    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
-    plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: 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;
-    customValidation(parameters: Partial<T>): Promise<void>;
-    abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
-    abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
-    applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;
-    abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;
-}