@codifycli/plugin-core 1.0.0-beta1

package/src/messages/handlers.ts

@@ -0,0 +1,181 @@
+import { Ajv, SchemaObject, ValidateFunction } from 'ajv';
+import addFormats from 'ajv-formats';
+import {
+  ApplyRequestDataSchema,
+  EmptyResponseDataSchema,
+  GetResourceInfoRequestDataSchema,
+  GetResourceInfoResponseDataSchema,
+  ImportRequestDataSchema,
+  ImportResponseDataSchema,
+  InitializeRequestDataSchema,
+  InitializeResponseDataSchema,
+  IpcMessage,
+  IpcMessageSchema,
+  IpcMessageV2,
+  IpcMessageV2Schema,
+  MatchRequestDataSchema,
+  MatchResponseDataSchema,
+  MessageStatus,
+  PlanRequestDataSchema,
+  PlanResponseDataSchema,
+  ResourceSchema,
+  SetVerbosityRequestDataSchema,
+  ValidateRequestDataSchema,
+  ValidateResponseDataSchema
+} from 'codify-schemas';
+
+import { SudoError } from '../errors.js';
+import { Plugin } from '../plugin/plugin.js';
+
+const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) => Promise<unknown>; requestValidator: SchemaObject; responseValidator: SchemaObject }> = {
+  'initialize': {
+    handler: async (plugin: Plugin, data: any) => plugin.initialize(data),
+    requestValidator: InitializeRequestDataSchema,
+    responseValidator: InitializeResponseDataSchema
+  },
+  'validate': {
+    handler: async (plugin: Plugin, data: any) => plugin.validate(data),
+    requestValidator: ValidateRequestDataSchema,
+    responseValidator: ValidateResponseDataSchema
+  },
+  'getResourceInfo': {
+    handler: async (plugin: Plugin, data: any) => plugin.getResourceInfo(data),
+    requestValidator: GetResourceInfoRequestDataSchema,
+    responseValidator: GetResourceInfoResponseDataSchema
+  },
+  'setVerbosityLevel': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.setVerbosityLevel(data)
+      return null;
+    },
+    requestValidator: SetVerbosityRequestDataSchema,
+    responseValidator: EmptyResponseDataSchema,
+  },
+  'match': {
+    handler: async (plugin: Plugin, data: any) => plugin.match(data),
+    requestValidator: MatchRequestDataSchema,
+    responseValidator: MatchResponseDataSchema
+  },
+  'import': {
+    handler: async (plugin: Plugin, data: any) => plugin.import(data),
+    requestValidator: ImportRequestDataSchema,
+    responseValidator: ImportResponseDataSchema
+  },
+  'plan': {
+    handler: async (plugin: Plugin, data: any) => plugin.plan(data),
+    requestValidator: PlanRequestDataSchema,
+    responseValidator: PlanResponseDataSchema
+  },
+  'apply': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.apply(data);
+      return null;
+    },
+    requestValidator: ApplyRequestDataSchema,
+    responseValidator: EmptyResponseDataSchema
+  },
+}
+
+export class MessageHandler {
+  private ajv: Ajv;
+  private readonly plugin: Plugin;
+  private messageSchemaValidatorV1: ValidateFunction;
+  private messageSchemaValidatorV2: ValidateFunction;
+  private requestValidators: Map<string, ValidateFunction>;
+  private responseValidators: Map<string, ValidateFunction>;
+
+  constructor(plugin: Plugin) {
+    this.ajv = new Ajv({ strict: true, strictRequired: false });
+    addFormats.default(this.ajv);
+    this.ajv.addSchema(ResourceSchema);
+    this.plugin = plugin;
+
+    this.messageSchemaValidatorV1 = this.ajv.compile(IpcMessageSchema);
+    this.messageSchemaValidatorV2 = this.ajv.compile(IpcMessageV2Schema);
+
+    this.requestValidators = new Map(
+      Object.entries(SupportedRequests)
+        .map(([k, v]) => [k, this.ajv.compile(v.requestValidator)])
+    )
+    this.responseValidators = new Map(
+      Object.entries(SupportedRequests)
+        .map(([k, v]) => [k, this.ajv.compile(v.responseValidator)])
+    )
+  }
+
+  async onMessage(message: unknown): Promise<void> {
+    try {
+      if (!this.validateMessageV2(message) && !this.validateMessage(message)) {
+        throw new Error(`Plugin: ${this.plugin}. Message is malformed: ${JSON.stringify(this.messageSchemaValidatorV1.errors, null, 2)}`);
+      }
+
+      if (!this.requestValidators.has(message.cmd)) {
+        throw new Error(`Plugin: ${this.plugin}. Unsupported message: ${message.cmd}`);
+      }
+
+      const requestValidator = this.requestValidators.get(message.cmd)!;
+      if (!requestValidator(message.data)) {
+        throw new Error(`Plugin: ${this.plugin}. cmd: ${message.cmd}. Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`)
+      }
+
+      const result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
+
+      const responseValidator = this.responseValidators.get(message.cmd);
+      if (responseValidator && !responseValidator(result)) {
+        throw new Error(`Plugin: ${this.plugin.name}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}. Received ${JSON.stringify(result, null, 2)}`);
+      }
+
+      process.send!({
+        cmd: message.cmd + '_Response',
+        data: result,
+        // @ts-expect-error TS2239
+        requestId: message.requestId || undefined,
+        status: MessageStatus.SUCCESS,
+      })
+
+    } catch (error: unknown) {
+      this.handleErrors(message, error as Error);
+    }
+  }
+
+  private validateMessage(message: unknown): message is IpcMessage {
+    return this.messageSchemaValidatorV1(message);
+  }
+
+  private validateMessageV2(message: unknown): message is IpcMessageV2 {
+    return this.messageSchemaValidatorV2(message);
+  }
+
+  private handleErrors(message: unknown, e: Error) {
+    if (!message) {
+      return;
+    }
+
+    if (!message.hasOwnProperty('cmd')) {
+      return;
+    }
+
+    // @ts-expect-error TS2239
+    const cmd = message.cmd + '_Response';
+
+    if (e instanceof SudoError) {
+      return process.send?.({
+        cmd,
+        // @ts-expect-error TS2239
+        requestId: message.requestId || undefined,
+        data: `Plugin: '${this.plugin.name}'. Forbidden usage of sudo for command '${e.command}'. Please contact the plugin developer to fix this.`,
+        status: MessageStatus.ERROR,
+      })
+    }
+
+    const isDebug = process.env.DEBUG?.includes('*') ?? false;
+
+    process.send?.({
+      cmd,
+      // @ts-expect-error TS2239
+      requestId: message.requestId || undefined,
+      data: isDebug ? e.stack : e.message,
+      status: MessageStatus.ERROR,
+    })
+  }
+}

package/src/messages/sender.ts

@@ -0,0 +1,69 @@
+import { Ajv } from 'ajv';
+import { IpcMessageV2, IpcMessageV2Schema, MessageCmd, PressKeyToContinueRequestData } from 'codify-schemas';
+import { nanoid } from 'nanoid';
+
+const ajv = new Ajv({
+  strict: true,
+});
+
+/**
+ * Send requests to the Codify CLI
+ */
+class CodifyCliSenderImpl {
+  private readonly validateIpcMessageV2 = ajv.compile(IpcMessageV2Schema);
+
+  async requestPressKeyToContinuePrompt(message?: string): Promise<void> {
+    await this.sendAndWaitForResponse(<IpcMessageV2>{
+      cmd: MessageCmd.PRESS_KEY_TO_CONTINUE_REQUEST,
+      data: <PressKeyToContinueRequestData>{
+        promptMessage: message,
+      }
+    })
+  }
+
+  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);
+      const listener = (data: IpcMessageV2) => {
+        if (data.requestId === requestId) {
+          process.removeListener('message', listener);
+
+          if (!this.validateIpcMessageV2(data)) {
+            throw new Error(`Invalid response for request.
+Request:                        
+${JSON.stringify(message, null, 2)}
+Response:
+${JSON.stringify(data, null, 2)}
+Error:
+${JSON.stringify(this.validateIpcMessageV2.errors, null, 2)}`);
+          }
+
+          resolve(data);
+        }
+      }
+
+      process.on('message', listener);
+
+      const ipcMessage = {
+        ...message,
+        requestId,
+      }
+      process.send!(ipcMessage)
+    })
+  }
+}
+
+export const CodifyCliSender = new CodifyCliSenderImpl();

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

@@ -0,0 +1,280 @@
+import { ChangeSet } from './change-set.js';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { describe, expect, it } from 'vitest';
+import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
+
+describe('Change set tests', () => {
+  it ('Correctly diffs two resource configs (modify)', () => {
+    const after = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const before = {
+      propA: 'after',
+      propB: 'after'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it ('Correctly diffs two resource configs (add)', () => {
+    const after = {
+      propA: 'before',
+      propB: 'after'
+    }
+
+    const before = {
+      propA: 'after',
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+
+  })
+
+  it ('Correctly diffs two resource configs (remove)', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it ('Correctly diffs two resource configs (no-op)', () => {
+    const after = {
+      propA: 'prop',
+    }
+
+    const before = {
+      propA: 'prop',
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP)
+  })
+
+  it('Correctly diffs two resource configs (create)', () => {
+    const cs = ChangeSet.create({
+      propA: 'prop',
+      propB: 'propB'
+    });
+
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.operation).to.eq(ResourceOperation.CREATE)
+  })
+
+  it('Correctly diffs two resource configs (destory)', () => {
+    const cs = ChangeSet.destroy({
+      propA: 'prop',
+      propB: 'propB',
+    });
+
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.DESTROY)
+  })
+
+  it ('handles simple arrays', () => {
+    const before = {
+      propA: ['a', 'b', 'c'],
+    }
+
+    const after = {
+      propA: ['b', 'a', 'c'],
+    }
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP)
+  })
+
+  it('handles simple arrays 2', () => {
+    const after = {
+      propA: ['a', 'b', 'c'],
+    }
+
+    const before = {
+      propA: ['b', 'a'],
+    }
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it('determines the order of operations with canModify 1', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { canModify: true }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it('determines the order of operations with canModify 2', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { canModify: true },
+        propB: { canModify: true }
+      },
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification<any>(after, before, parameterSettings);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.MODIFY)
+  })
+
+
+  it('correctly determines array equality', () => {
+    const arrA = ['a', 'b', 'd'];
+    const arrB = ['a', 'b', 'd'];
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
+
+    expect(result.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('correctly determines array equality 2', () => {
+    const arrA = ['a', 'b'];
+    const arrB = ['a', 'b', 'd'];
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it('correctly determines array equality 3', () => {
+    const arrA = ['b', 'a', 'd'];
+    const arrB = ['a', 'b', 'd'];
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+
+  it('correctly determines array equality 4', () => {
+    const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
+    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: {
+          type: 'array',
+          isElementEqual: (a, b) => a.key1 === b.key1
+        }
+      },
+    }).parameterSettings
+
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it('correctly determines array equality 5', () => {
+    const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
+    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
+
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: {
+          type: 'array',
+          isElementEqual: (a, b) => a.key1 === b.key1
+        }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+})