codify-plugin-lib 1.0.177 → 1.0.178

package/dist/messages/sender.d.ts

@@ -4,6 +4,7 @@
 declare class CodifyCliSenderImpl {
     private readonly validateIpcMessageV2;
     requestPressKeyToContinuePrompt(message?: string): Promise<void>;
+    getCodifyCliCredentials(): Promise<string>;
     private sendAndWaitForResponse;
 }
 export declare const CodifyCliSender: CodifyCliSenderImpl;

package/dist/messages/sender.js

@@ -17,6 +17,16 @@ class CodifyCliSenderImpl {
             }
         });
     }
+    async getCodifyCliCredentials() {
+        const data = await this.sendAndWaitForResponse({
+            cmd: MessageCmd.CODIFY_CREDENTIALS_REQUEST,
+            data: {},
+        });
+        if (typeof data.data !== 'string') {
+            throw new Error('Expected string back from credentials request');
+        }
+        return data.data;
+    }
     async sendAndWaitForResponse(message) {
         return new Promise((resolve) => {
             const requestId = nanoid(8);

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

@@ -24,7 +24,7 @@ export declare class ResourceController<T extends StringIndexedObject> {
     private applyModify;
     private applyDestroy;
     private validateRefreshResults;
-    private applyTransformParameters;
+    private applyTransformations;
     private addDefaultValues;
     private removeDefaultValues;
     private refreshNonStatefulParameters;

package/dist/resource/resource-controller.js

@@ -33,7 +33,7 @@ export class ResourceController {
     }
     async validate(core, parameters) {
         const originalParameters = structuredClone(parameters);
-        await this.applyTransformParameters(parameters);
+        await this.applyTransformations(parameters, undefined, true);
         this.addDefaultValues(parameters);
         if (this.schemaValidator) {
             // Schema validator uses pre transformation parameters
@@ -103,9 +103,9 @@ export class ResourceController {
             const originalParams = structuredClone(resource.parameters);
             const paramsToMatch = structuredClone(resourceToMatch.parameters);
             this.addDefaultValues(originalParams);
-            await this.applyTransformParameters(originalParams);
+            await this.applyTransformations(originalParams);
             this.addDefaultValues(paramsToMatch);
-            await this.applyTransformParameters(paramsToMatch);
+            await this.applyTransformations(paramsToMatch);
             const match = parameterMatcher(originalParams, paramsToMatch);
             if (match) {
                 return resourceToMatch;
@@ -120,9 +120,9 @@ export class ResourceController {
             originalDesiredConfig: structuredClone(desired),
         };
         this.addDefaultValues(desired);
-        await this.applyTransformParameters(desired);
+        await this.applyTransformations(desired);
         this.addDefaultValues(state);
-        await this.applyTransformParameters(state);
+        await this.applyTransformations(state);
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters);
         const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
@@ -156,7 +156,7 @@ export class ResourceController {
     }
     async planDestroy(core, parameters) {
         this.addDefaultValues(parameters);
-        await this.applyTransformParameters(parameters);
+        await this.applyTransformations(parameters);
         // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
         const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
             ? {
@@ -211,7 +211,7 @@ export class ResourceController {
             return results.filter(Boolean).flat();
         }
         this.addDefaultValues(parameters);
-        await this.applyTransformParameters(parameters);
+        await this.applyTransformations(parameters);
         // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
         const parametersToRefresh = this.getParametersToRefreshForImport(parameters, context);
         // Parse data from the user supplied config
@@ -227,7 +227,7 @@ export class ResourceController {
         const resultParametersArray = currentParametersArray
             ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }));
         for (const result of resultParametersArray) {
-            await this.applyTransformParameters(result, { original: context.originalDesiredConfig });
+            await this.applyTransformations(result, { original: context.originalDesiredConfig });
             this.removeDefaultValues(result, parameters);
         }
         return resultParametersArray?.map((r) => ({ core, parameters: r }));
@@ -292,7 +292,7 @@ ${JSON.stringify(refresh, null, 2)}
 `);
         }
     }
-    async applyTransformParameters(config, reverse) {
+    async applyTransformations(config, reverse, skipConfigTransformation = false) {
         if (!config) {
             return;
         }
@@ -304,7 +304,7 @@ ${JSON.stringify(refresh, null, 2)}
                 ? await inputTransformation.from(config[key], reverse.original?.[key])
                 : await inputTransformation.to(config[key]);
         }
-        if (this.settings.transformation) {
+        if (this.settings.transformation && !skipConfigTransformation) {
             const transformed = reverse
                 ? await this.settings.transformation.from({ ...config }, reverse.original)
                 : await this.settings.transformation.to({ ...config });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.177",
+  "version": "1.0.178",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.76",
+    "codify-schemas": "1.0.77",
     "@npmcli/promise-spawn": "^7.0.1",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0-beta.5",
     "uuid": "^10.0.0",

package/src/messages/sender.ts

@@ -21,6 +21,19 @@ class CodifyCliSenderImpl {
     })
   }
 
+  async getCodifyCliCredentials(): Promise<string> {
+    const data = await this.sendAndWaitForResponse(<IpcMessageV2>{
+      cmd: MessageCmd.CODIFY_CREDENTIALS_REQUEST,
+      data: {},
+    })
+
+    if (typeof data.data !== 'string') {
+      throw new Error('Expected string back from credentials request');
+    }
+
+    return data.data;
+  }
+
   private async sendAndWaitForResponse(message: IpcMessageV2): Promise<IpcMessageV2> {
     return new Promise((resolve) => {
       const requestId = nanoid(8);

package/src/resource/resource-controller.ts

@@ -59,7 +59,7 @@ export class ResourceController<T extends StringIndexedObject> {
     parameters: Partial<T>,
   ): Promise<ValidateResponseData['resourceValidations'][0]> {
     const originalParameters = structuredClone(parameters);
-    await this.applyTransformParameters(parameters);
+    await this.applyTransformations(parameters, undefined, true);
     this.addDefaultValues(parameters);
 
     if (this.schemaValidator) {
@@ -143,10 +143,10 @@ export class ResourceController<T extends StringIndexedObject> {
       const paramsToMatch = structuredClone(resourceToMatch.parameters) as Partial<T>;
 
       this.addDefaultValues(originalParams);
-      await this.applyTransformParameters(originalParams);
+      await this.applyTransformations(originalParams);
 
       this.addDefaultValues(paramsToMatch);
-      await this.applyTransformParameters(paramsToMatch);
+      await this.applyTransformations(paramsToMatch);
 
       const match = parameterMatcher(originalParams, paramsToMatch);
       if (match) {
@@ -170,10 +170,10 @@ export class ResourceController<T extends StringIndexedObject> {
     };
 
     this.addDefaultValues(desired);
-    await this.applyTransformParameters(desired);
+    await this.applyTransformations(desired);
 
     this.addDefaultValues(state);
-    await this.applyTransformParameters(state);
+    await this.applyTransformations(state);
 
     // Parse data from the user supplied config
     const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters)
@@ -221,7 +221,7 @@ export class ResourceController<T extends StringIndexedObject> {
     parameters: Partial<T>
   ): Promise<Plan<T>> {
     this.addDefaultValues(parameters);
-    await this.applyTransformParameters(parameters);
+    await this.applyTransformations(parameters);
 
     // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
     const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
@@ -298,7 +298,7 @@ export class ResourceController<T extends StringIndexedObject> {
     }
 
     this.addDefaultValues(parameters);
-    await this.applyTransformParameters(parameters);
+    await this.applyTransformations(parameters);
 
     // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
     const parametersToRefresh = this.getParametersToRefreshForImport(parameters, context);
@@ -325,7 +325,7 @@ export class ResourceController<T extends StringIndexedObject> {
       ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }))
 
     for (const result of resultParametersArray) {
-      await this.applyTransformParameters(result, { original: context.originalDesiredConfig });
+      await this.applyTransformations(result, { original: context.originalDesiredConfig });
       this.removeDefaultValues(result, parameters);
     }
 
@@ -408,9 +408,9 @@ ${JSON.stringify(refresh, null, 2)}
     }
   }
 
-  private async applyTransformParameters(config: Partial<T> | null, reverse?: {
+  private async applyTransformations(config: Partial<T> | null, reverse?: {
     original: Partial<T> | null
-  }): Promise<void> {
+  }, skipConfigTransformation = false): Promise<void> {
     if (!config) {
       return;
     }
@@ -425,7 +425,7 @@ ${JSON.stringify(refresh, null, 2)}
         : await inputTransformation.to(config[key]);
     }
 
-    if (this.settings.transformation) {
+    if (this.settings.transformation && !skipConfigTransformation) {
       const transformed = reverse
         ? await this.settings.transformation.from({ ...config }, reverse.original)
         : await this.settings.transformation.to({ ...config })

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

@@ -1,24 +0,0 @@
-import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { ParameterOptions } 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<T extends StringIndexedObject> {
-    operation: ResourceOperation;
-    parameterChanges: Array<ParameterChange<T>>;
-    constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange<T>>);
-    get desiredParameters(): T;
-    get currentParameters(): T;
-    static calculateParameterChangeSet<T extends StringIndexedObject>(desired: T | null, current: T | null, options: {
-        statefulMode: boolean;
-        parameterOptions?: Record<keyof T, ParameterOptions>;
-    }): ParameterChange<T>[];
-    static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
-    static isSame(desired: unknown, current: unknown, options?: ParameterOptions): boolean;
-    private static calculateStatefulModeChangeSet;
-    private static calculateStatelessModeChangeSet;
-    private static addDefaultValues;
-}

package/dist/entities/change-set.js

@@ -1,152 +0,0 @@
-import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-export class ChangeSet {
-    operation;
-    parameterChanges;
-    constructor(operation, parameterChanges) {
-        this.operation = operation;
-        this.parameterChanges = parameterChanges;
-    }
-    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 calculateParameterChangeSet(desired, current, options) {
-        if (options.statefulMode) {
-            return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterOptions);
-        }
-        else {
-            return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterOptions);
-        }
-    }
-    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(desired, current, options) {
-        if (options?.isEqual) {
-            return options.isEqual(desired, current);
-        }
-        if (Array.isArray(desired) && Array.isArray(current)) {
-            const sortedDesired = desired.map((x) => x).sort();
-            const sortedCurrent = current.map((x) => x).sort();
-            if (sortedDesired.length !== sortedCurrent.length) {
-                return false;
-            }
-            if (options?.isElementEqual) {
-                return sortedDesired.every((value, index) => options.isElementEqual(value, sortedCurrent[index]));
-            }
-            return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
-        }
-        return desired === current;
-    }
-    static calculateStatefulModeChangeSet(desired, current, parameterOptions) {
-        const parameterChangeSet = new Array();
-        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
-        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
-        this.addDefaultValues(_desired, parameterOptions);
-        for (const [k, v] of Object.entries(_current)) {
-            if (_desired[k] == null) {
-                parameterChangeSet.push({
-                    name: k,
-                    previousValue: v,
-                    newValue: null,
-                    operation: ParameterOperation.REMOVE,
-                });
-                delete _current[k];
-                continue;
-            }
-            if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
-                parameterChangeSet.push({
-                    name: k,
-                    previousValue: v,
-                    newValue: _desired[k],
-                    operation: ParameterOperation.MODIFY,
-                });
-                delete _current[k];
-                delete _desired[k];
-                continue;
-            }
-            parameterChangeSet.push({
-                name: k,
-                previousValue: v,
-                newValue: _desired[k],
-                operation: ParameterOperation.NOOP,
-            });
-            delete _current[k];
-            delete _desired[k];
-        }
-        if (Object.keys(_current).length !== 0) {
-            throw Error('Diff algorithm error');
-        }
-        for (const [k, v] of Object.entries(_desired)) {
-            parameterChangeSet.push({
-                name: k,
-                previousValue: null,
-                newValue: v,
-                operation: ParameterOperation.ADD,
-            });
-        }
-        return parameterChangeSet;
-    }
-    static calculateStatelessModeChangeSet(desired, current, parameterOptions) {
-        const parameterChangeSet = new Array();
-        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
-        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
-        this.addDefaultValues(_desired, parameterOptions);
-        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(_desired[k], _current[k], parameterOptions?.[k])) {
-                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 parameterChangeSet;
-    }
-    static addDefaultValues(obj, options) {
-        Object.entries(options ?? {})
-            .filter(([, option]) => option.default !== undefined)
-            .map(([name, option]) => [name, option.default])
-            .forEach(([key, defaultValue]) => {
-            if (obj[key] === undefined) {
-                obj[key] = defaultValue;
-            }
-        });
-    }
-}

package/dist/entities/errors.d.ts

@@ -1,4 +0,0 @@
-export declare class SudoError extends Error {
-    command: string;
-    constructor(command: string);
-}

package/dist/entities/errors.js

@@ -1,7 +0,0 @@
-export class SudoError extends Error {
-    command;
-    constructor(command) {
-        super();
-        this.command = command;
-    }
-}

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

@@ -1,25 +0,0 @@
-import { Plan } from './plan.js';
-import { StringIndexedObject } from 'codify-schemas';
-export interface ParameterOptions {
-    modifyOnChange?: boolean;
-    isEqual?: (desired: any, current: any) => boolean;
-    isElementEqual?: (desired: any, current: any) => boolean;
-    default?: unknown;
-    isStatefulParameter?: boolean;
-}
-export interface PlanOptions<T> {
-    statefulMode: boolean;
-    parameterOptions?: Record<keyof T, ParameterOptions>;
-}
-export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
-    desiredConfig: T;
-    currentConfig: null;
-}
-export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
-    desiredConfig: null;
-    currentConfig: T;
-}
-export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
-    desiredConfig: T;
-    currentConfig: T;
-}

package/dist/entities/plan-types.js

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

package/dist/entities/plan.d.ts

@@ -1,15 +0,0 @@
-import { ChangeSet } from './change-set.js';
-import { ApplyRequestData, PlanResponseData, ResourceConfig, StringIndexedObject } from 'codify-schemas';
-import { PlanOptions } from './plan-types.js';
-export declare class Plan<T extends StringIndexedObject> {
-    id: string;
-    changeSet: ChangeSet<T>;
-    resourceMetadata: ResourceConfig;
-    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
-    static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, options: PlanOptions<T>): Plan<T>;
-    getResourceType(): string;
-    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
-    get desiredConfig(): T | null;
-    get currentConfig(): T | null;
-    toResponse(): PlanResponseData;
-}

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