codify-schemas 1.0.0

package/.mocharc.json

@@ -0,0 +1,7 @@
+{
+  "require": "ts-node/register",
+  "extensions": ["ts"],
+  "spec": [
+    "src/**/*.test.ts"
+  ]
+}

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateResponseDataSchema = exports.ValidateRequestDataSchema = exports.PlanResponseDataSchema = exports.PlanRequestDataSchema = exports.ErrorResponseDataSchema = exports.ApplyRequestDataSchema = exports.IpcMessageSchema = exports.ResourceSchema = exports.ResourceMetaSchema = exports.ProjectSchema = exports.ConfigFileSchema = void 0;
+var config_file_schema_json_1 = require("./config-file-schema.json");
+Object.defineProperty(exports, "ConfigFileSchema", { enumerable: true, get: function () { return __importDefault(config_file_schema_json_1).default; } });
+var project_schema_json_1 = require("./project-schema.json");
+Object.defineProperty(exports, "ProjectSchema", { enumerable: true, get: function () { return __importDefault(project_schema_json_1).default; } });
+var resource_meta_schema_json_1 = require("./resource-meta-schema.json");
+Object.defineProperty(exports, "ResourceMetaSchema", { enumerable: true, get: function () { return __importDefault(resource_meta_schema_json_1).default; } });
+var resource_schema_json_1 = require("./resource-schema.json");
+Object.defineProperty(exports, "ResourceSchema", { enumerable: true, get: function () { return __importDefault(resource_schema_json_1).default; } });
+var ipc_message_schema_json_1 = require("./ipc-message-schema.json");
+Object.defineProperty(exports, "IpcMessageSchema", { enumerable: true, get: function () { return __importDefault(ipc_message_schema_json_1).default; } });
+var apply_request_data_schema_json_1 = require("./messages/apply-request-data-schema.json");
+Object.defineProperty(exports, "ApplyRequestDataSchema", { enumerable: true, get: function () { return __importDefault(apply_request_data_schema_json_1).default; } });
+var error_response_data_schema_json_1 = require("./messages/error-response-data-schema.json");
+Object.defineProperty(exports, "ErrorResponseDataSchema", { enumerable: true, get: function () { return __importDefault(error_response_data_schema_json_1).default; } });
+var plan_request_data_schema_json_1 = require("./messages/plan-request-data-schema.json");
+Object.defineProperty(exports, "PlanRequestDataSchema", { enumerable: true, get: function () { return __importDefault(plan_request_data_schema_json_1).default; } });
+var plan_response_data_schema_json_1 = require("./messages/plan-response-data-schema.json");
+Object.defineProperty(exports, "PlanResponseDataSchema", { enumerable: true, get: function () { return __importDefault(plan_response_data_schema_json_1).default; } });
+var validate_request_data_schema_json_1 = require("./messages/validate-request-data-schema.json");
+Object.defineProperty(exports, "ValidateRequestDataSchema", { enumerable: true, get: function () { return __importDefault(validate_request_data_schema_json_1).default; } });
+var validate_response_data_schema_json_1 = require("./messages/validate-response-data-schema.json");
+Object.defineProperty(exports, "ValidateResponseDataSchema", { enumerable: true, get: function () { return __importDefault(validate_response_data_schema_json_1).default; } });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "codify-schemas",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "tsc": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ajv": "^8.12.0"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.11",
+    "@types/mocha": "^10.0.6",
+    "chai": "^5.0.3",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/src/config-file-schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/config-file-schema.json",
+  "title": "Config file Schema",
+  "type": "array",
+  "items": {
+    "$ref": "resource-schema.json"
+  }
+}

package/src/config-file-schema.test.ts

@@ -0,0 +1,52 @@
+import Ajv2020 from "ajv/dist/2020";
+import configSchema from './config-file-schema.json';
+import resourceSchema from './resource-schema.json';
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+  strict: true,
+})
+ajv.addSchema(resourceSchema);
+
+describe("config file schema tests", () => {
+  it('compiles', () => {
+    ajv.compile(configSchema);
+  })
+
+  it('accepts resource blocks', () => {
+    const validator = ajv.compile(configSchema);
+
+    assert.equal(validator([
+      {
+        "type": "resource1",
+      },
+      {
+        "type": "resource2",
+        "name": "abc",
+        "prop1": {
+          "a": "b",
+        },
+        "prop2": "c"
+      }
+    ]), true)
+
+    assert.equal(validator([
+      {
+        "type": "resource1",
+      },
+      {}
+    ]), false)
+
+    assert.equal(validator([
+      {
+        "type": "project",
+      },
+      {
+        "type": "resource2"
+      }
+    ]), true)
+
+  })
+
+
+})

package/src/index.ts

@@ -0,0 +1,12 @@
+export { default as ConfigFileSchema } from './config-file-schema.json';
+export { default as ProjectSchema } from './project-schema.json';
+export { default as ResourceMetaSchema } from './resource-meta-schema.json';
+export { default as ResourceSchema } from './resource-schema.json';
+export { default as IpcMessageSchema } from './ipc-message-schema.json';
+export { default as ApplyRequestDataSchema } from './messages/apply-request-data-schema.json';
+export { default as ErrorResponseDataSchema } from './messages/error-response-data-schema.json';
+export { default as PlanRequestDataSchema } from './messages/plan-request-data-schema.json';
+export { default as PlanResponseDataSchema } from './messages/plan-response-data-schema.json';
+export { default as ValidateRequestDataSchema } from './messages/validate-request-data-schema.json';
+export { default as ValidateResponseDataSchema } from './messages/validate-response-data-schema.json';
+export * from './types';

package/src/ipc-message-schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/ipc-message-schema.json",
+  "title": "IPC Message Schema",
+  "type": "object",
+  "properties": {
+    "cmd": {
+      "description": "The uri for the message. Like an http url",
+      "type": "string"
+    },
+    "status": {
+      "description": "The status of the request. Only used for responses. Can be either success or error",
+      "type": "string",
+      "enum": ["success", "error"]
+    },
+    "data": {
+      "description": "The data of the message."
+    }
+  },
+  "required": ["cmd", "data"]
+}

package/src/ipc-message-schema.test.ts

@@ -0,0 +1,37 @@
+import Ajv2020 from "ajv/dist/2020";
+import { describe, it } from 'mocha';
+import schema from './ipc-message-schema.json';
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+  strict: true,
+})
+
+describe("Ipc message schema tests", () => {
+  it("compiles", () => {
+    ajv.compile(schema);
+  })
+
+  it("requires a cmd field to be specified", () => {
+    const validate = ajv.compile(schema);
+    assert.equal(validate({ cmd: "doSomething", data: "data" }), true)
+    assert.equal(validate({ data: "data" }), false)
+  })
+
+  it("has an optional status field for responses", () => {
+    const validate = ajv.compile(schema);
+    assert.equal(validate({ cmd: "doSomething", status: "success", data: "data" }), true)
+    assert.equal(validate({ cmd: "doSomething", status: "error", data: "data" }), true)
+    assert.equal(validate({ cmd: "doSomething", status: "other", data: "data" }), false)
+    assert.equal(validate({ cmd: "doSomething", data: "data" }), true)
+  })
+
+  it ("accepts data or null", () => {
+    const validate = ajv.compile(schema);
+    assert.equal(validate({ cmd: "doSomething", data: "data" }), true)
+    assert.equal(validate({ cmd: "doSomething", data: null }), true)
+    assert.equal(validate({ cmd: "doSomething" }), false)
+    assert.equal(validate({ cmd: "doSomething", data: {} }), true)
+  });
+
+});

package/src/messages/apply-request-data-schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/apply-request-data-schema.json",
+  "title": "Apply Request Schema Data",
+  "description": "Apply the previously generated plan. The plan must already be generated in order for apply to work.",
+  "type": "object",
+  "properties": {
+    "planId": {
+      "description": "The plan uuid. This id is used to look up the generated plan on the plugin side",
+      "type": "string",
+      "format": "uuid"
+    }
+  },
+  "required": ["planId"],
+  "additionalProperties": false
+}

package/src/messages/apply-response-data-schema.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/apply-response-data-schema.json",
+  "title": "Apply Response Schema Data",
+  "type": "null",
+  "additionalProperties": false
+}

package/src/messages/error-response-data-schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/error-response-data-schema.json",
+  "title": "Error Response Schema Data",
+  "type": "object",
+  "properties": {
+    "reason": {
+      "description": "A human read-able reason for the error",
+      "type": "string"
+    }
+  },
+  "required": ["reason"],
+  "additionalProperties": false
+}

package/src/messages/get-resources-response-data-schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/get-resources-response-data-schema.json",
+  "title": "Get Resources Response Schema Data",
+  "type": "object",
+  "properties": {
+    "resources": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "$ref": "resource-schema.json#/properties/type"
+          },
+          "dependencies": {
+            "type": "array",
+            "items":  {
+              "type": "string"
+            }
+          }
+        },
+        "required": ["type"]
+      }
+    }
+  },
+  "required": ["resources"],
+  "additionalProperties": false
+}

package/src/messages/get-resources-response-data-schema.test.ts

@@ -0,0 +1,43 @@
+import Ajv2020 from "ajv/dist/2020";
+import schema from './get-resources-response-data-schema.json';
+import resourceSchema from '../resource-schema.json'
+import {it} from "mocha";
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+  strict: true,
+})
+ajv.addSchema(resourceSchema);
+
+describe('Get resources response data schema', () => {
+  it('compiles', () => {
+    ajv.compile(schema);
+  })
+
+  it("requires a type field to be specified", () => {
+    const validate = ajv.compile(schema);
+    assert.equal(validate({ resources: [
+        {
+          type: "typeA",
+          dependencies: [
+            "typeB"
+          ]
+        },
+        {
+          type: "typeB"
+        }
+    ]}), true)
+    assert.equal(validate({
+      resources: [
+        {
+          type: "typeA",
+          dependencies: [
+            "typeB"
+          ]
+        },
+        {}
+      ]
+    }), false)
+  })
+
+})

package/src/messages/plan-request-data-schema.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/plan-request-data-schema.json",
+  "title": "Plan Request Schema Data",
+  "$ref": "resource-schema.json"
+}

package/src/messages/plan-request-data-schema.test.ts

@@ -0,0 +1,34 @@
+import Ajv2020 from "ajv/dist/2020";
+import schema from './plan-request-data-schema.json';
+import resourceSchema from '../resource-schema.json'
+import {it} from "mocha";
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+  strict: true,
+})
+ajv.addSchema(resourceSchema);
+
+describe('Plan request data schema', () => {
+  it('compiles', () => {
+    ajv.compile(schema);
+  })
+
+  it("requires a type field to be specified", () => {
+    const validate = ajv.compile(schema);
+    assert.equal(validate({ type: "type" }), true)
+    assert.equal(validate({}), false)
+  })
+
+  it ("name and type are alpha-numeric and follow variable naming conventions", () => {
+    const validate = ajv.compile(schema);
+    assert.equal(validate({ type: "a234abcDEF_-"}), true)
+    assert.equal(validate({ type: "234"}), false);
+    assert.equal(validate({ type: "ABCDEF$"}), false);
+
+    assert.equal(validate({ type: "type", name: "a234abcDEF_-"}), true)
+    assert.equal(validate({ type: "type", name: "234"}), false);
+    assert.equal(validate({ type: "type", name: "ABCDEF$"}), false);
+  });
+
+})

package/src/messages/plan-response-data-schema.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/plan-response-data-schema.json",
+  "title": "Plan Response Schema Data",
+  "type": "object",
+  "properties": {
+    "planId": {
+      "description": "The id of the plan to look up for the apply operation",
+      "type": "string",
+      "format": "uuid"
+    },
+    "operation": {
+      "description": "The plan operation",
+      "type": "string",
+      "enum" : ["create", "destroy", "modify", "recreate", "noop"]
+    },
+    "resourceType": {
+      "description": "The resource type",
+      "type": "string"
+    },
+    "resourceName": {
+      "description": "The resource name",
+      "type": ["string", "null"]
+    },
+    "parameters": {
+      "description": "The properties come from the provided config and is not necessarily every parameter on the ",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "description": "The property name",
+            "type": "string"
+          },
+          "operation": {
+            "description": "The operation to be performed on the parameter",
+            "type": "string",
+            "enum": ["remove", "add", "modify", "noop"]
+          },
+          "previousValue": {
+            "description": "The value before the change"
+          },
+          "newValue": {
+            "description": "The new value"
+          }
+        },
+        "required": ["name", "operation", "previousValue", "newValue"]
+      }
+    }
+  },
+  "required": ["planId", "operation", "resourceType", "parameters"],
+  "additionalProperties": false
+}

package/src/messages/validate-request-data-schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/validate-request-data-schema.json",
+  "title": "Validate Request Schema Data",
+  "type": "object",
+  "properties": {
+    "configs": {
+      "type": "array",
+      "items": {
+        "$ref": "resource-schema.json"
+      }
+    }
+  },
+  "required": [],
+  "additionalProperties": false
+}

package/src/messages/validate-response-data-schema.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/validate-response-data-schema.json",
+  "title": "Validate Response Schema Data",
+  "type": "null"
+}

package/src/project-schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/resource-schema.json",
+  "title": "Resource Schema",
+  "type": "object",
+  "properties": {
+    "type": {
+      "description": "All project configs are of the type project",
+      "type": "string",
+      "const": "project"
+    },
+    "version": {
+      "description": "Semver version. Codify will throw an error if this is not satisfied",
+      "type": "string",
+      "pattern": "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+)?$"
+    },
+    "plugins": {
+      "type": "object",
+      "patternProperties": {
+        ".*": {
+          "type": "string"
+        }
+      }
+    },
+    "description": {
+      "description": "An optional description of the codify project",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false,
+  "required": ["type"]
+}

package/src/project-schema.test.ts

@@ -0,0 +1,47 @@
+import Ajv2020 from "ajv/dist/2020";
+import schema from './project-schema.json';
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+  strict: true,
+})
+
+describe("project file schema tests", () => {
+  it('compiles', () => {
+    ajv.compile(schema);
+  })
+
+  it("must have type project", () => {
+    const validator = ajv.compile(schema);
+    assert.equal(validator({ type: 'project' }), true)
+    assert.equal(validator({}), false)
+    assert.equal(validator({ type: 'resource' }), false)
+  })
+
+  it("plugins must be <string, string>", () => {
+    const validator = ajv.compile(schema);
+    assert.equal(validator({
+      type: 'project',
+      plugins: {
+        "plugin1": "3.2.3"
+      }
+    }), true)
+
+    assert.equal(validator({
+      type: 'project',
+      plugins: {
+        "plugin1": 1,
+      }
+    }), false)
+
+    assert.equal(validator({
+      type: 'project',
+      plugins: {
+        "plugins2": "https://link.to.plugin.com"
+      }
+    }), true)
+  })
+
+
+
+})

package/src/resource-meta-schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Config file Schema",
+  "type": "object",
+  "properties": {
+    "$id": {
+      "type": "string",
+      "pattern": "^https://www.codify.com/"
+    },
+    "type": {
+      "const": "object"
+    },
+    "properties": {
+      "type": "object",
+      "properties": {
+        "type": false,
+        "name": false,
+        "dependsOn": false,
+        "$ref": {
+          "const": "https://www.codify.com/resource-schema.json#properties"
+        }
+      }
+    },
+    "$ref": {
+      "const": "https://www.codify.com/resource-schema.json"
+    },
+    "unevaluatedProperties": {
+      "const": false
+    }
+  },
+  "required": ["unevaluatedProperties", "$ref"]
+}

package/src/resource-meta-schema.test.ts

@@ -0,0 +1,121 @@
+import Ajv2020 from "ajv/dist/2020";
+import { describe, it } from 'mocha';
+import schema from './resource-meta-schema.json';
+import resourceSchema from './resource-schema.json';
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+   strict: true,
+})
+
+describe("Resource meta schema tests", () => {
+   it("compiles", () => {
+      ajv.compile(schema);
+   })
+
+   it("must have additional properties and $ref to resource-schema specified", () => {
+      const validate = ajv.compile(schema);
+
+      assert.equal(validate({
+         "$schema": "https://json-schema.org/draft/2020-12/schema",
+         "type": "object",
+         "properties": {
+            "prop1": {
+               "type": "string"
+            }
+         }
+      }), false);
+
+      assert.equal(validate({
+         "$schema": "https://json-schema.org/draft/2020-12/schema",
+         "type": "object",
+         "properties": {
+            "prop1": {
+               "type": "string"
+            }
+         },
+         "additionalProperties": false,
+         "$ref": "https://www.codify.com/resource-schema.json"
+      }), true);
+   })
+
+   it("does not allow resource keywords to be specified", () => {
+      const validate = ajv.compile(schema);
+
+      assert.equal(validate({
+         "$schema": "https://json-schema.org/draft/2020-12/schema",
+         "type": "object",
+         "properties": {
+            "type": {
+               "type": "string"
+            }
+         },
+         "additionalProperties": false,
+         "$ref": "https://www.codify.com/resource-schema.json"
+      }), false);
+
+      assert.equal(validate({
+         "$schema": "https://json-schema.org/draft/2020-12/schema",
+         "type": "object",
+         "properties": {
+            "name": {
+               "type": "string"
+            }
+         },
+         "additionalProperties": false,
+         "$ref": "https://www.codify.com/resource-schema.json"
+      }), false);
+
+      assert.equal(validate({
+         "$schema": "https://json-schema.org/draft/2020-12/schema",
+         "type": "object",
+         "properties": {
+            "dependsOn": {
+               "type": "array"
+            }
+         },
+         "additionalProperties": false,
+         "$ref": "https://www.codify.com/resource-schema.json"
+      }), false);
+   })
+
+   it("allows for schema composition with base resource schema", () => {
+      const resourceMetaSchema = schema;
+      const propertySchema = {
+         $id: "https://www.codify.com/property-schema.json",
+         type: "object",
+         properties: {
+            prop1: {
+               type: "string"
+            },
+            prop2: {
+               type: "string"
+            },
+         },
+         $ref: "https://www.codify.com/resource-schema.json",
+         unevaluatedProperties: false,
+      }
+
+      const resourceConfigInvalid = {
+         prop1: "a",
+      }
+
+      const resourceConfigValid = {
+         type: "resource-config",
+         prop1: "a",
+         dependsOn: ["resource-config-2"]
+      }
+
+      const ajv = new Ajv2020({
+         strict: true,
+         schemas: [resourceSchema]
+      });
+
+      const metaSchemaValidator = ajv.compile(resourceMetaSchema);
+      assert.equal(metaSchemaValidator(propertySchema), true)
+
+      const resourceValidator = ajv.compile(propertySchema);
+      assert.equal(resourceValidator(resourceConfigValid), true);
+      assert.equal(resourceValidator(resourceConfigInvalid), false);
+   })
+});

package/src/resource-schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.codify.com/resource-schema.json",
+  "title": "Resource Schema",
+  "type": "object",
+  "properties": {
+    "type": {
+      "description": "The resource type",
+      "type": "string",
+      "pattern": "^[a-zA-Z-_][\\w-]+$"
+    },
+    "name": {
+      "description": "Optional name. Useful for specifying multiple resources of the same type",
+      "type": "string",
+      "pattern": "^[a-zA-Z-_][\\w-]+$"
+    },
+    "dependsOn": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "uniqueItems": true
+    }
+  },
+  "required": ["type"]
+}

package/src/resource-schema.test.ts

@@ -0,0 +1,39 @@
+import Ajv2020 from "ajv/dist/2020";
+import { describe, it } from 'mocha';
+import schema from './resource-schema.json';
+import assert from "node:assert";
+
+const ajv = new Ajv2020({
+   strict: true,
+})
+
+describe("Resource schema tests", () => {
+   it("compiles", () => {
+      ajv.compile(schema);
+   })
+
+   it("requires a type field to be specified", () => {
+      const validate = ajv.compile(schema);
+      assert.equal(validate({ type: "type" }), true)
+      assert.equal(validate({}), false)
+   })
+
+   it ("name and type are alpha-numeric and follow variable naming conventions", () => {
+      const validate = ajv.compile(schema);
+      assert.equal(validate({ type: "a234abcDEF_-"}), true)
+      assert.equal(validate({ type: "234"}), false);
+      assert.equal(validate({ type: "ABCDEF$"}), false);
+
+      assert.equal(validate({ type: "type", name: "a234abcDEF_-"}), true)
+      assert.equal(validate({ type: "type", name: "234"}), false);
+      assert.equal(validate({ type: "type", name: "ABCDEF$"}), false);
+   });
+
+   it("dependsOn is an array of unique strings", () => {
+      const validate = ajv.compile(schema);
+      assert.equal(validate({ type: "type", dependsOn: ["item1", "item2"] }), true)
+      assert.equal(validate({ type: "type", dependsOn: ["item1", "item1"] }), false)
+      assert.equal(validate({ type: "type", dependsOn: "item1" }), false)
+      assert.equal(validate({ type: "type", dependsOn: [6] }), false)
+   })
+});

package/src/types/index.ts

@@ -0,0 +1,63 @@
+export interface ProjectConfig {
+  type: string;
+  version?: string;
+  plugins?: Record<string, string>;
+  description?: string;
+}
+
+export interface ResourceConfig {
+  type: string;
+  name?: string;
+  dependsOn?: string[];
+}
+
+export enum MessageStatus {
+  SUCCESS = 'success',
+  ERROR = 'error',
+}
+
+export interface IpcMessage {
+  cmd: string;
+  status?: MessageStatus;
+  data: unknown | null;
+}
+
+export interface ValidateRequestData {
+  configs: ResourceConfig[];
+}
+
+export type ValidateResponseData = null;
+
+export interface PlanRequestData extends ResourceConfig {}
+
+export enum ResourceOperation {
+  CREATE = "create",
+  DESTROY = "destroy",
+  MODIFY = "modify",
+  RECREATE = "recreate",
+  NOOP = "noop"
+}
+
+export enum ParameterOperation {
+  ADD = "add",
+  REMOVE = "remove",
+  MODIFY = "modify",
+  NOOP = "noop"
+}
+
+export interface PlanResponseData {
+  planId: string;
+  operation: ResourceOperation;
+  resourceName?: string;
+  resourceType: string;
+  parameters: Array<{
+    name: string;
+    operation: ParameterOperation;
+    previousValue: string | null;
+    newValue: string | null;
+  }>
+}
+
+export interface ApplyRequestData {
+  planId: string;
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "alwaysStrict": true,
+    "noImplicitAny": true,
+    "removeComments": true,
+    "strictNullChecks": true,
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "rootDir": "src",
+    "outDir": "./dist"
+  },
+  "exclude": [
+    "node_modules",
+    "src/**/*.test.ts"
+  ],
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "tsconfig.json",
+  "compilerOptions": {
+    "strictNullChecks": false
+  },
+  "include": [
+    "src/**/*.test.ts"
+  ],
+}