codify-plugin-lib 1.0.177 → 1.0.178

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>;
-}

package/dist/entities/resource.js

@@ -1,303 +0,0 @@
-import { Ajv } from 'ajv';
-import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
-import { setsEqual, splitUserConfig } from '../utils/utils.js';
-import { Plan } from './plan.js';
-import { ResourceOptionsParser } from './resource-options.js';
-export class Resource {
-    typeId;
-    statefulParameters;
-    transformParameters;
-    resourceParameters;
-    statefulParameterOrder;
-    transformParameterOrder;
-    dependencies;
-    parameterOptions;
-    options;
-    defaultValues;
-    ajv;
-    schemaValidator;
-    constructor(options) {
-        this.typeId = options.type;
-        this.dependencies = options.dependencies ?? [];
-        this.options = options;
-        if (this.options.schema) {
-            this.ajv = new Ajv({
-                allErrors: true,
-                strict: true,
-                strictRequired: false,
-            });
-            this.schemaValidator = this.ajv.compile(this.options.schema);
-        }
-        const parser = new ResourceOptionsParser(options);
-        this.statefulParameters = parser.statefulParameters;
-        this.transformParameters = parser.transformParameters;
-        this.resourceParameters = parser.resourceParameters;
-        this.parameterOptions = parser.changeSetParameterOptions;
-        this.defaultValues = parser.defaultValues;
-        this.statefulParameterOrder = parser.statefulParameterOrder;
-        this.transformParameterOrder = parser.transformParameterOrder;
-    }
-    async onInitialize() { }
-    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.customValidation(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, currentConfig = null, statefulMode = false) {
-        this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
-        const planOptions = {
-            parameterOptions: this.parameterOptions,
-            statefulMode,
-        };
-        this.addDefaultValues(desiredConfig);
-        await this.applyTransformParameters(desiredConfig);
-        const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
-        const { desiredParameters, nonStatefulParameters, resourceMetadata, statefulParameters, } = parsedConfig;
-        const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
-        if (currentParameters === null || currentParameters === undefined) {
-            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
-        }
-        const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
-        return Plan.create(desiredParameters, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
-    }
-    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.applyCreate(plan);
-        const statefulParameterChanges = plan.changeSet.parameterChanges
-            .filter((pc) => this.statefulParameters.has(pc.name))
-            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.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, plan);
-        }
-        const statefulParameterChanges = parameterChanges
-            .filter((pc) => this.statefulParameters.has(pc.name))
-            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.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;
-                }
-                case ParameterOperation.MODIFY: {
-                    await statefulParameter.applyModify(parameterChange.newValue, parameterChange.previousValue, false, plan);
-                    break;
-                }
-                case ParameterOperation.REMOVE: {
-                    await statefulParameter.applyRemove(parameterChange.previousValue, plan);
-                    break;
-                }
-            }
-        }
-    }
-    async _applyDestroy(plan) {
-        if (this.options.callStatefulParameterRemoveOnDestroy) {
-            const statefulParameterChanges = plan.changeSet.parameterChanges
-                .filter((pc) => this.statefulParameters.has(pc.name))
-                .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
-            for (const parameterChange of statefulParameterChanges) {
-                const statefulParameter = this.statefulParameters.get(parameterChange.name);
-                await statefulParameter.applyRemove(parameterChange.previousValue, plan);
-            }
-        }
-        await this.applyDestroy(plan);
-    }
-    validateRefreshResults(refresh, desired) {
-        if (!refresh) {
-            return;
-        }
-        const desiredKeys = new Set(Object.keys(refresh));
-        const refreshKeys = new Set(Object.keys(refresh));
-        if (!setsEqual(desiredKeys, refreshKeys)) {
-            throw new Error(`Resource ${this.typeId}
-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 applyTransformParameters(desired) {
-        if (!desired) {
-            return;
-        }
-        const transformParameters = [...this.transformParameters.entries()]
-            .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
-        for (const [key, transformParameter] of transformParameters) {
-            if (desired[key] === undefined) {
-                continue;
-            }
-            const transformedValue = await transformParameter.transform(desired[key]);
-            if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
-                throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
-            }
-            delete desired[key];
-            for (const [tvKey, tvValue] of Object.entries(transformedValue)) {
-                desired[tvKey] = tvValue;
-            }
-        }
-    }
-    addDefaultValues(desired) {
-        if (!desired) {
-            return;
-        }
-        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
-            if (defaultValue !== undefined && desired[key] === undefined) {
-                desired[key] = defaultValue;
-            }
-        }
-    }
-    async refreshNonStatefulParameters(resourceParameters) {
-        const currentParameters = await this.refresh(resourceParameters);
-        this.validateRefreshResults(currentParameters, resourceParameters);
-        return currentParameters;
-    }
-    async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {
-        const currentParameters = {};
-        const sortedEntries = Object.entries(statefulParametersConfig)
-            .sort(([key1], [key2]) => this.statefulParameterOrder.get(key1) - this.statefulParameterOrder.get(key2));
-        for (const [key, desiredValue] of sortedEntries) {
-            const statefulParameter = this.statefulParameters.get(key);
-            if (!statefulParameter) {
-                throw new Error(`Stateful parameter ${key} was not found`);
-            }
-            let currentValue = await statefulParameter.refresh(desiredValue ?? null);
-            if (Array.isArray(currentValue)
-                && Array.isArray(desiredValue)
-                && !isStatefulMode
-                && !statefulParameter.options.disableStatelessModeArrayFiltering) {
-                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
-                    const parameterOptions = statefulParameter.options;
-                    if (parameterOptions && parameterOptions.isElementEqual) {
-                        return parameterOptions.isElementEqual(d, c);
-                    }
-                    return d === c;
-                }));
-            }
-            currentParameters[key] = currentValue;
-        }
-        return currentParameters;
-    }
-    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');
-        }
-    }
-    async customValidation(parameters) { }
-    ;
-    async applyModify(pc, plan) { }
-    ;
-}
-class ConfigParser {
-    desiredConfig;
-    currentConfig;
-    statefulParametersMap;
-    transformParametersMap;
-    constructor(desiredConfig, currentConfig, statefulParameters, transformParameters) {
-        this.desiredConfig = desiredConfig;
-        this.currentConfig = currentConfig;
-        this.statefulParametersMap = statefulParameters;
-        this.transformParametersMap = transformParameters;
-    }
-    get resourceMetadata() {
-        const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
-        const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
-        if (!desiredMetadata && !currentMetadata) {
-            throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`);
-        }
-        if (currentMetadata && desiredMetadata && (Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
-            || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value))) {
-            throw new Error(`The metadata for the current config does not match the desired config. 
-Desired metadata:
-${JSON.stringify(desiredMetadata, null, 2)}
-
-Current metadata:
-${JSON.stringify(currentMetadata, null, 2)}`);
-        }
-        return desiredMetadata ?? currentMetadata;
-    }
-    get desiredParameters() {
-        if (!this.desiredConfig) {
-            return null;
-        }
-        const { parameters } = splitUserConfig(this.desiredConfig);
-        return parameters;
-    }
-    get parameters() {
-        const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
-        const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
-        return { ...desiredParameters, ...currentParameters };
-    }
-    get nonStatefulParameters() {
-        const { parameters } = this;
-        return Object.fromEntries(Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))));
-    }
-    get statefulParameters() {
-        const { parameters } = this;
-        return Object.fromEntries(Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)));
-    }
-}

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

@@ -1,29 +0,0 @@
-import { Plan } from './plan.js';
-import { StringIndexedObject } from 'codify-schemas';
-export interface StatefulParameterOptions<V> {
-    isEqual?: (desired: any, current: any) => boolean;
-    disableStatelessModeArrayFiltering?: boolean;
-    default?: V;
-}
-export interface ArrayStatefulParameterOptions<V> extends StatefulParameterOptions<V> {
-    isEqual?: (desired: any[], current: any[]) => boolean;
-    isElementEqual?: (desired: any, current: any) => boolean;
-}
-export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
-    readonly options: StatefulParameterOptions<V>;
-    constructor(options?: StatefulParameterOptions<V>);
-    abstract refresh(desired: 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> {
-    options: ArrayStatefulParameterOptions<V>;
-    constructor(options?: ArrayStatefulParameterOptions<V>);
-    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(desired: 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,46 +0,0 @@
-export class StatefulParameter {
-    options;
-    constructor(options = {}) {
-        this.options = options;
-    }
-}
-export class ArrayStatefulParameter extends StatefulParameter {
-    options;
-    constructor(options = {}) {
-        super(options);
-        this.options = options;
-    }
-    async applyAdd(valuesToAdd, plan) {
-        for (const value of valuesToAdd) {
-            await this.applyAddItem(value, plan);
-        }
-    }
-    async applyModify(newValues, previousValues, allowDeletes, plan) {
-        const options = this.options;
-        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
-            if (options.isElementEqual) {
-                return options.isElementEqual(n, p);
-            }
-            return n === p;
-        }));
-        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
-            if (options.isElementEqual) {
-                return options.isElementEqual(n, p);
-            }
-            return n === p;
-        }));
-        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/transform-parameter.d.ts

@@ -1,4 +0,0 @@
-import { StringIndexedObject } from 'codify-schemas';
-export declare abstract class TransformParameter<T extends StringIndexedObject> {
-    abstract transform(value: any): Promise<Partial<T>>;
-}

package/dist/entities/transform-parameter.js

@@ -1,2 +0,0 @@
-export class TransformParameter {
-}

package/dist/pty/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/pty/vitest.config.js

@@ -1,11 +0,0 @@
-import { defaultExclude, defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        pool: 'forks',
-        fileParallelism: false,
-        exclude: [
-            ...defaultExclude,
-            './src/utils/test-utils.test.ts',
-        ]
-    },
-});