@terraforge/terraform 0.0.23 → 0.0.25

package/dist/index.d.mts

@@ -1,5 +1,11 @@
 //#region src/plugin/schema.d.ts
 
+type RootProperty = {
+  type: 'object';
+  version?: number;
+  description?: string;
+  properties: Record<string, Property>;
+};
 type Property = {
   description?: string;
   required?: boolean;
@@ -13,6 +19,7 @@ type Property = {
 } | {
   type: 'array' | 'record';
   item: Property;
+  collectionKind?: 'list' | 'set';
 } | {
   type: 'object' | 'array-object';
   properties: Record<string, Property>;
@@ -28,8 +35,8 @@ type State$1 = Record<string, unknown>;
 type Plugin = Readonly<{
   schema: () => {
     provider: Property;
-    resources: Record<string, Property>;
-    dataSources: Record<string, Property>;
+    resources: Record<string, RootProperty>;
+    dataSources: Record<string, RootProperty>;
   };
   stop: () => Promise<void>;
   configure: (config: State$1) => Promise<void>;
@@ -197,8 +204,12 @@ type RefreshResourceProps<T = State> = {
   priorOutputState: T;
 };
 type RefreshResourceResult<T = State> = {
-  kind: 'unchanged' | 'updated';
+  kind: 'unchanged';
+  state: T;
+} | {
+  kind: 'updated';
   state: T;
+  inputState: T;
 } | {
   kind: 'deleted';
 };
@@ -303,12 +314,15 @@ declare class TerraformProvider implements Provider {
   }: RefreshResourceProps): Promise<{
     kind: "deleted";
     state?: undefined;
+    inputState?: undefined;
   } | {
     kind: "unchanged";
     state: State$1;
+    inputState?: undefined;
   } | {
     kind: "updated";
     state: State$1;
+    inputState: State;
   }>;
 }
 //#endregion

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { camelCase, pascalCase, snakeCase } from "change-case";
 import { ResourceNotFound, createDebugger, createMeta, nodeMetaSymbol } from "@terraforge/core";
+import { pack, unpack } from "msgpackr";
 import { credentials, loadPackageDefinition } from "@grpc/grpc-js";
 import { fromJSON } from "@grpc/proto-loader";
 import jszip from "jszip";
@@ -8,7 +9,6 @@ import { arch, homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { compare } from "semver";
 import { spawn } from "node:child_process";
-import { pack, unpack } from "msgpackr";
 
 //#region src/type-gen.ts
 const tab = (indent) => {
@@ -215,6 +215,215 @@ const generateValue = (prop, ctx) => {
 	throw new Error(`Unknown property type: ${prop.type}`);
 };
 
+//#endregion
+//#region src/plugin/version/util.ts
+const stableStringify = (value) => {
+	return JSON.stringify(value, (_, item) => {
+		if (item !== null && item instanceof Object && !Array.isArray(item)) return Object.keys(item).sort().reduce((sorted, key) => {
+			sorted[key] = item[key];
+			return sorted;
+		}, {});
+		return item;
+	});
+};
+const sortStateValues = (values) => {
+	return [...values].sort((left, right) => {
+		const l = stableStringify(left);
+		const r = stableStringify(right);
+		if (l < r) return -1;
+		if (l > r) return 1;
+		return 0;
+	});
+};
+const encodeDynamicValue = (value) => {
+	return {
+		msgpack: pack(value),
+		json: value
+	};
+};
+const decodeDynamicValue = (value) => {
+	return unpack(value.msgpack);
+};
+const getResourceSchema = (resources, type) => {
+	const resource = resources[type];
+	if (!resource) throw new Error(`Unknown resource type: ${type}`);
+	return resource;
+};
+const formatAttributePath = (state) => {
+	if (!state) return [];
+	return state.map((item) => {
+		if (!item.steps) throw new Error("AttributePath should always have steps");
+		return item.steps.map((attr) => {
+			if ("attributeName" in attr) return attr.attributeName;
+			if ("elementKeyString" in attr) return attr.elementKeyString;
+			if ("elementKeyInt" in attr) return attr.elementKeyInt;
+			throw new Error("AttributePath step should always have an element");
+		});
+	});
+};
+const getNestedValue = (obj, path) => {
+	let current = obj;
+	for (const key of path) {
+		if (current === null || current === void 0) return current;
+		if (Array.isArray(current)) current = current[key];
+		else if (typeof current === "object") current = current[key];
+		else return;
+	}
+	return current;
+};
+const filterRequiresReplace = (paths, priorState, proposedState) => {
+	return paths.filter((path) => {
+		const priorValue = getNestedValue(priorState, path);
+		const proposedValue = getNestedValue(proposedState, path);
+		return JSON.stringify(priorValue) !== JSON.stringify(proposedValue);
+	});
+};
+var IncorrectType = class extends TypeError {
+	constructor(type, path) {
+		super(`${path.join(".")} should be a ${type}`);
+	}
+};
+const isEmptyOutputValue = (value) => {
+	if (value === null || typeof value === "undefined") return true;
+	if (Array.isArray(value)) return value.length === 0;
+	if (typeof value === "object") return Object.keys(value).length === 0;
+	return false;
+};
+const shouldOmitOutputValue = (schema, value) => {
+	if (!(schema.optional || schema.computed)) return false;
+	return isEmptyOutputValue(value);
+};
+const hasInputValue = (value) => typeof value !== "undefined";
+const shouldIncludeFieldForComparison = (schema, inputValue) => {
+	return schema.required || hasInputValue(inputValue);
+};
+const normalizeStateForComparison = (schema, state, inputState) => {
+	if (!shouldIncludeFieldForComparison(schema, inputState)) return;
+	if (state === null || typeof state === "undefined") return state;
+	if (schema.type === "array") {
+		if (!Array.isArray(state)) return state;
+		const normalized = state.map((item, index) => {
+			const inputItem = Array.isArray(inputState) ? inputState[index] : void 0;
+			return normalizeStateForComparison(schema.item, item, inputItem);
+		});
+		return schema.collectionKind === "set" ? sortStateValues(normalized) : normalized;
+	}
+	if (schema.type === "record") {
+		if (typeof state !== "object" || state === null) return state;
+		return Object.fromEntries(Object.entries(state).map(([key, value]) => {
+			const inputValue = inputState && typeof inputState === "object" ? inputState[key] : void 0;
+			return [key, normalizeStateForComparison(schema.item, value, inputValue)];
+		}));
+	}
+	if (schema.type === "object") {
+		if (typeof state !== "object" || state === null) return state;
+		return Object.fromEntries(Object.entries(schema.properties).flatMap(([key, prop]) => {
+			const stateValue = state[camelCase(key)];
+			const normalized = normalizeStateForComparison(prop, stateValue, inputState && typeof inputState === "object" ? inputState[camelCase(key)] : void 0);
+			if (typeof normalized === "undefined") return [];
+			return [[camelCase(key), normalized]];
+		}));
+	}
+	if (schema.type === "array-object") {
+		if (typeof state !== "object" || state === null) return state;
+		return Object.fromEntries(Object.entries(schema.properties).flatMap(([key, prop]) => {
+			const stateValue = state[camelCase(key)];
+			const normalized = normalizeStateForComparison(prop, stateValue, inputState && typeof inputState === "object" ? inputState[camelCase(key)] : void 0);
+			if (typeof normalized === "undefined") return [];
+			return [[camelCase(key), normalized]];
+		}));
+	}
+	return state;
+};
+const formatInputState = (schema, state, includeSchemaFields = true, path = []) => {
+	if (state === null) return null;
+	if (typeof state === "undefined") return null;
+	if (schema.type === "unknown") return state;
+	if (schema.type === "string") {
+		if (typeof state === "string") return state;
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "number") {
+		if (typeof state === "number") return state;
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "boolean") {
+		if (typeof state === "boolean") return state;
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "array") {
+		if (Array.isArray(state)) return state.map((item, i) => formatInputState(schema.item, item, includeSchemaFields, [...path, i]));
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "record") {
+		if (typeof state === "object" && state !== null) {
+			const record = {};
+			for (const [key, value] of Object.entries(state)) record[key] = formatInputState(schema.item, value, includeSchemaFields, [...path, key]);
+			return record;
+		}
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "object" || schema.type === "array-object") {
+		if (typeof state === "object" && state !== null) {
+			const object = {};
+			if (includeSchemaFields) for (const [key, prop] of Object.entries(schema.properties)) {
+				const value = state[camelCase(key)];
+				object[key] = formatInputState(prop, value, true, [...path, key]);
+			}
+			else for (const [key, value] of Object.entries(state)) {
+				const prop = schema.properties[snakeCase(key)];
+				if (prop) object[key] = formatInputState(prop, value, false, [...path, key]);
+			}
+			if (schema.type === "array-object") return [object];
+			return object;
+		}
+		throw new IncorrectType(schema.type, path);
+	}
+	throw new Error(`Unknown schema type: ${schema.type}`);
+};
+const formatOutputState = (schema, state, path = []) => {
+	if (state === null || state === void 0) return null;
+	if (schema.type === "array") {
+		if (Array.isArray(state)) return state.map((item, i) => formatOutputState(schema.item, item, [...path, i]));
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "record") {
+		if (typeof state === "object" && state !== null) {
+			const record = {};
+			for (const [key, value] of Object.entries(state)) record[key] = formatOutputState(schema.item, value, [...path, key]);
+			return record;
+		}
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "object") {
+		if (typeof state === "object" && state !== null) {
+			const object = {};
+			for (const [key, prop] of Object.entries(schema.properties)) {
+				const value = state[key];
+				const formatted = formatOutputState(prop, value, [...path, key]);
+				if (shouldOmitOutputValue(prop, formatted)) continue;
+				object[camelCase(key)] = formatted;
+			}
+			return object;
+		}
+		throw new IncorrectType(schema.type, path);
+	}
+	if (schema.type === "array-object") {
+		if (Array.isArray(state)) if (state.length === 1) {
+			const object = {};
+			for (const [key, prop] of Object.entries(schema.properties)) {
+				const value = state[0][key];
+				const formatted = formatOutputState(prop, value, [...path, key]);
+				if (shouldOmitOutputValue(prop, formatted)) continue;
+				object[camelCase(key)] = formatted;
+			}
+			return object;
+		} else return null;
+		throw new IncorrectType(schema.type, path);
+	}
+	return state;
+};
+
 //#endregion
 //#region src/provider.ts
 const areStatesEqual = (left, right) => {
@@ -317,6 +526,7 @@ var TerraformProvider = class {
 	}
 	async refreshResource({ type, priorInputState, priorOutputState }) {
 		const plugin = await this.configure();
+		const schema = getResourceSchema(plugin.schema().resources, type);
 		const refreshedState = await plugin.readResource(type, priorOutputState);
 		if (!refreshedState) return { kind: "deleted" };
 		const mergedState = {
@@ -324,19 +534,16 @@ var TerraformProvider = class {
 			...priorInputState
 		};
 		const { requiresReplace, plannedState } = await plugin.planResourceChange(type, refreshedState, mergedState, priorInputState);
-		if (requiresReplace.length === 0 && areStatesEqual(plannedState, refreshedState)) return {
+		const normalizedPlannedState = normalizeStateForComparison(schema, plannedState, priorInputState);
+		const normalizedRefreshedState = normalizeStateForComparison(schema, refreshedState, priorInputState);
+		if (requiresReplace.length === 0 && areStatesEqual(normalizedPlannedState, normalizedRefreshedState)) return {
 			kind: "unchanged",
 			state: refreshedState
 		};
-		console.log("TYPE", type);
-		console.log("PRIOR_INPUT_STATE", priorInputState);
-		console.log("PRIOR_OUTPUT_STATE", priorOutputState);
-		console.log("PLANNED_STATE", plannedState);
-		console.log("REFRESH_STATE", refreshedState);
-		console.log("REQUIRES_REPLACE", requiresReplace);
 		return {
 			kind: "updated",
-			state: refreshedState
+			state: refreshedState,
+			inputState: normalizedRefreshedState
 		};
 	}
 };
@@ -1892,7 +2099,8 @@ const parseNestedBlock = (block) => {
 	if (type === "array" || type === "record") return {
 		...prop,
 		type,
-		item
+		item,
+		collectionKind: block.nesting === NestingMode.SET ? "set" : "list"
 	};
 	if (type === "array-object") return {
 		...prop,
@@ -1939,12 +2147,14 @@ const parseAttribute = (attr) => {
 };
 const parseAttributeType = (item) => {
 	if (Array.isArray(item)) {
-		const type$1 = parseType(item[0]);
+		const sourceType = item[0];
+		const type$1 = parseType(sourceType);
 		if (type$1 === "array" || type$1 === "record" && item) {
 			const record = item[1];
 			return {
 				type: type$1,
-				item: parseAttributeType(record)
+				item: parseAttributeType(record),
+				collectionKind: sourceType === "set" ? "set" : "list"
 			};
 		}
 		if (type$1 === "object") {
@@ -1981,155 +2191,6 @@ const parseType = (type) => {
 	throw new Error(`Invalid type: ${type}`);
 };
 
-//#endregion
-//#region src/plugin/version/util.ts
-const encodeDynamicValue = (value) => {
-	return {
-		msgpack: pack(value),
-		json: value
-	};
-};
-const decodeDynamicValue = (value) => {
-	return unpack(value.msgpack);
-};
-const getResourceSchema = (resources, type) => {
-	const resource = resources[type];
-	if (!resource) throw new Error(`Unknown resource type: ${type}`);
-	return resource;
-};
-const formatAttributePath = (state) => {
-	if (!state) return [];
-	return state.map((item) => {
-		if (!item.steps) throw new Error("AttributePath should always have steps");
-		return item.steps.map((attr) => {
-			if ("attributeName" in attr) return attr.attributeName;
-			if ("elementKeyString" in attr) return attr.elementKeyString;
-			if ("elementKeyInt" in attr) return attr.elementKeyInt;
-			throw new Error("AttributePath step should always have an element");
-		});
-	});
-};
-const getNestedValue = (obj, path) => {
-	let current = obj;
-	for (const key of path) {
-		if (current === null || current === void 0) return current;
-		if (Array.isArray(current)) current = current[key];
-		else if (typeof current === "object") current = current[key];
-		else return;
-	}
-	return current;
-};
-const filterRequiresReplace = (paths, priorState, proposedState) => {
-	return paths.filter((path) => {
-		const priorValue = getNestedValue(priorState, path);
-		const proposedValue = getNestedValue(proposedState, path);
-		return JSON.stringify(priorValue) !== JSON.stringify(proposedValue);
-	});
-};
-var IncorrectType = class extends TypeError {
-	constructor(type, path) {
-		super(`${path.join(".")} should be a ${type}`);
-	}
-};
-const isEmptyOutputValue = (value) => {
-	if (value === null || typeof value === "undefined") return true;
-	if (Array.isArray(value)) return value.length === 0;
-	if (typeof value === "object") return Object.keys(value).length === 0;
-	return false;
-};
-const shouldOmitOutputValue = (schema, value) => {
-	if (!(schema.optional || schema.computed)) return false;
-	return isEmptyOutputValue(value);
-};
-const formatInputState = (schema, state, includeSchemaFields = true, path = []) => {
-	if (state === null) return null;
-	if (typeof state === "undefined") return null;
-	if (schema.type === "unknown") return state;
-	if (schema.type === "string") {
-		if (typeof state === "string") return state;
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "number") {
-		if (typeof state === "number") return state;
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "boolean") {
-		if (typeof state === "boolean") return state;
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "array") {
-		if (Array.isArray(state)) return state.map((item, i) => formatInputState(schema.item, item, includeSchemaFields, [...path, i]));
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "record") {
-		if (typeof state === "object" && state !== null) {
-			const record = {};
-			for (const [key, value] of Object.entries(state)) record[key] = formatInputState(schema.item, value, includeSchemaFields, [...path, key]);
-			return record;
-		}
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "object" || schema.type === "array-object") {
-		if (typeof state === "object" && state !== null) {
-			const object = {};
-			if (includeSchemaFields) for (const [key, prop] of Object.entries(schema.properties)) {
-				const value = state[camelCase(key)];
-				object[key] = formatInputState(prop, value, true, [...path, key]);
-			}
-			else for (const [key, value] of Object.entries(state)) {
-				const prop = schema.properties[snakeCase(key)];
-				if (prop) object[key] = formatInputState(prop, value, false, [...path, key]);
-			}
-			if (schema.type === "array-object") return [object];
-			return object;
-		}
-		throw new IncorrectType(schema.type, path);
-	}
-	throw new Error(`Unknown schema type: ${schema.type}`);
-};
-const formatOutputState = (schema, state, path = []) => {
-	if (state === null || state === void 0) return null;
-	if (schema.type === "array") {
-		if (Array.isArray(state)) return state.map((item, i) => formatOutputState(schema.item, item, [...path, i]));
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "record") {
-		if (typeof state === "object" && state !== null) {
-			const record = {};
-			for (const [key, value] of Object.entries(state)) record[key] = formatOutputState(schema.item, value, [...path, key]);
-			return record;
-		}
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "object") {
-		if (typeof state === "object" && state !== null) {
-			const object = {};
-			for (const [key, prop] of Object.entries(schema.properties)) {
-				const value = state[key];
-				const formatted = formatOutputState(prop, value, [...path, key]);
-				if (shouldOmitOutputValue(prop, formatted)) continue;
-				object[camelCase(key)] = formatted;
-			}
-			return object;
-		}
-		throw new IncorrectType(schema.type, path);
-	}
-	if (schema.type === "array-object") {
-		if (Array.isArray(state)) if (state.length === 1) {
-			const object = {};
-			for (const [key, prop] of Object.entries(schema.properties)) {
-				const value = state[0][key];
-				const formatted = formatOutputState(prop, value, [...path, key]);
-				if (shouldOmitOutputValue(prop, formatted)) continue;
-				object[camelCase(key)] = formatted;
-			}
-			return object;
-		} else return null;
-		throw new IncorrectType(schema.type, path);
-	}
-	return state;
-};
-
 //#endregion
 //#region src/plugin/version/5.ts
 const createPlugin5 = async ({ server, client }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terraforge/terraform",
-	"version": "0.0.23",
+	"version": "0.0.25",
 	"type": "module",
 	"repository": {
 		"type": "git",