@terraforge/terraform 0.0.1

package/cli/build-package.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env bun
+
+import { parseArgs } from 'util'
+import { createLazyPlugin } from '../src/lazy-plugin'
+import { Version } from '../src/plugin/registry'
+import { generateTypes } from '../src/type-gen'
+
+const { values } = parseArgs({
+	args: Bun.argv,
+	options: {
+		org: {
+			type: 'string',
+		},
+		type: {
+			type: 'string',
+		},
+	},
+	strict: true,
+	allowPositionals: true,
+})
+
+if (!values.org) {
+	console.error('Missing required arguments: org')
+	process.exit(1)
+}
+
+if (!values.type) {
+	console.error('Missing required arguments: type')
+	process.exit(1)
+}
+
+const packageData = (await Bun.file('./package.json').json()) as { version?: Version }
+
+if (!packageData) {
+	console.error('Failed to read package.json')
+	process.exit(1)
+}
+
+if (!packageData.version) {
+	console.error('Missing required arguments: version')
+	process.exit(1)
+}
+
+const org = values.org
+const type = values.type
+const version = packageData.version
+
+console.log('org:     ', org)
+console.log('type:    ', type)
+console.log('version: ', version)
+
+const ok = confirm('Continue?')
+
+if (!ok) {
+	process.exit(0)
+}
+
+const load = createLazyPlugin({ org, type, version })
+const plugin = await load()
+const schema = plugin.schema()
+const types = generateTypes(
+	{
+		[type]: schema.provider,
+	},
+	schema.resources,
+	schema.dataSources
+)
+
+await plugin.stop()
+
+await Bun.write(`./src/types.ts`, types)
+
+await Bun.write(
+	`./src/index.ts`,
+	`
+import { createTerraformAPI } from '@terraforge/terraform'
+import { root } from './types.ts'
+
+export const ${type} = createTerraformAPI<typeof root.${type}>({
+	namespace: '${type}',
+	provider: { org: '${org}', type: '${type}', version: '${version}' },
+}) as typeof root.${type}
+`
+)

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+type Version = `${number}.${number}.${number}` | "latest";
+type TerraformProviderConfig = {
+	id?: string;
+	location?: string;
+};
+declare const createTerraformAPI: <T>(props: {
+	namespace: string;
+	provider: {
+		org: string;
+		type: string;
+		version: Version;
+	};
+}) => T;
+type Property = {
+	description?: string;
+	required?: boolean;
+	optional?: boolean;
+	/** The computed field means that it could be computed by the server. */
+	computed?: boolean;
+	deprecated?: boolean;
+	sensitive?: boolean;
+} & ({
+	type: "string" | "number" | "boolean";
+} | {
+	type: "array" | "record";
+	item: Property;
+} | {
+	type: "object" | "array-object";
+	properties: Record<string, Property>;
+} | {
+	type: "unknown";
+});
+declare const generateTypes: (providers: Record<string, Property>, resources: Record<string, Property>, dataSources: Record<string, Property>) => string;
+import { CreateProps, DeleteProps, GetDataProps, GetProps, Provider, State as State2, UpdateProps } from "@terraforge/core";
+type State = Record<string, unknown>;
+type Plugin = Readonly<{
+	schema: () => {
+		provider: Property;
+		resources: Record<string, Property>;
+		dataSources: Record<string, Property>;
+	};
+	stop: () => Promise<void>;
+	configure: (config: State) => Promise<void>;
+	readResource: (type: string, state: State) => Promise<State>;
+	readDataSource: (type: string, state: State) => Promise<State>;
+	validateResource: (type: string, state: State) => Promise<void>;
+	planResourceChange: (type: string, priorState: State | null, proposedNewState: State | null) => Promise<{
+		requiresReplace: Array<string | number>[];
+		plannedState: State;
+	}>;
+	applyResourceChange: (type: string, priorState: State | null, proposedNewState: State | null) => Promise<State>;
+}>;
+declare class TerraformProvider implements Provider {
+	private type;
+	private id;
+	private createPlugin;
+	private config;
+	private configured?;
+	private plugin?;
+	constructor(type: string, id: string, createPlugin: () => Promise<Plugin>, config: State2);
+	private configure;
+	private prepare;
+	destroy(): Promise<void>;
+	ownResource(id: string): boolean;
+	getResource({ type, state }: GetProps);
+	createResource({ type, state }: CreateProps);
+	updateResource({ type, priorState, proposedState }: UpdateProps);
+	deleteResource({ type, state }: DeleteProps);
+	getData({ type, state }: GetDataProps);
+}
+export { generateTypes, createTerraformAPI, TerraformProviderConfig, TerraformProvider };