@terraforge/terraform 0.0.8 → 0.0.10

package/README.md

@@ -3,6 +3,59 @@
 
 This package is used to build Terraform bridge packages that can be used with @terraforge/core.
 
-### Installation location
+It works in 3 steps:
+
+1. It provides a build script that generates the typescript typings for your Terraform bridge package.
+
+2. It provides a proxy api that can we used to interact with Terraform resources.
+
+3. It will install the Terraform provider that you specify in your bridge package.
+
+### Terraform Plugin installation location
 
 The default installation location is `~/.terraforge/plugins`.
+
+## Usage Guide
+
+### Step 1. Create a package.json
+Create a package.json for the bridge package you want to create.
+In the `package.json` file, you will need to specify the provider details that your package is for.
+Example: 
+```json
+{
+	"name": "@terraforge/aws",
+	"version": "1.0.0",
+	"provider": { // These are the terraform provider details that your package is for.
+		"org": "hashicorp",
+		"type": "aws",
+		"version": "1.0.0"
+	},
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "bun ../terraform/cli/build-package",
+		"prepublishOnly": "bun run build"
+	},
+	"peerDependencies": {
+		"@terraforge/terraform": "workspace:*",
+		"@terraforge/core": "workspace:*"
+	}
+}
+```
+
+### Step 2. Publish your package
+You can now publish your package to npm or any other package registry.
+The prepublish script will build the package files inside the `dist` directory before publishing.
+
+### Step 3. There is no step 3
+Sit back and relax, your package is now published and ready to be used.

package/cli/build-package.ts

@@ -13,25 +13,30 @@ const packageData = (await Bun.file('./package.json').json()) as {
 	}
 }
 
-if (!packageData || !packageData.provider) {
+if (!packageData) {
 	console.error('Failed to read package.json')
 	process.exit(1)
 }
 
 const providerData = packageData.provider
 
+if (!providerData) {
+	console.error('Missing required property: provider')
+	process.exit(1)
+}
+
 if (!providerData.version) {
-	console.error('Missing required arguments: version')
+	console.error('Missing required property: provider.version')
 	process.exit(1)
 }
 
 if (!providerData.org) {
-	console.error('Missing required arguments: org')
+	console.error('Missing required property: provider.org')
 	process.exit(1)
 }
 
 if (!providerData.type) {
-	console.error('Missing required arguments: type')
+	console.error('Missing required property: provider.type')
 	process.exit(1)
 }
 
@@ -60,29 +65,51 @@ console.log('')
 console.log('Loading provider plugin...')
 
 const plugin = await load()
+
+console.log('Provider plugin loaded.')
+
 const schema = plugin.schema()
-const types = generateTypes(
-	{
-		[type]: schema.provider,
-	},
-	schema.resources,
-	schema.dataSources
-)
 
 await plugin.stop()
 
-await Bun.write(`./dist/index.d.ts`, types)
+// const installTypes = generateInstallHelperFunctions(type)
+// await Bun.write(`./dist/install.d.ts`, installTypes)
+
+// const providerTypes = generateProviderFactoryTypes(type, schema.provider)
+// await Bun.write(`./dist/provider.d.ts`, providerTypes)
+
+// const resourceTypes = generateResourceTypes(schema.resources)
+// await Bun.write(`./dist/resources.d.ts`, resourceTypes)
+
+// const dataSourceTypes = generateResourceTypes(schema.dataSources)
+// await Bun.write(`./dist/data-sources.d.ts`, dataSourceTypes)
+
+// await Bun.write(
+// 	`./dist/index.d.ts`,
+// 	`
+// /// <reference path="./install.d.ts" />
+// /// <reference path="./provider.d.ts" />
+// /// <reference path="./resources.d.ts" />
+// /// <reference path="./data-sources.d.ts" />
+
+// export { aws }
+// `
+// )
+
+await Bun.write(`./dist/index.d.ts`, generateTypes(type, schema.provider, schema.resources, schema.dataSources))
+
 await Bun.write(
 	`./dist/index.js`,
 	`
-import { createTerraformAPI } from '@terraforge/terraform'
+import { createTerraformProxy } from '@terraforge/terraform'
 
-export const ${type} = createTerraformAPI({
+export const ${type} = createTerraformProxy({
 	namespace: '${type}',
 	provider: { org: '${org}', type: '${type}', version: '${version}' },
 })
 `
 )
 
-console.log('Done.')
+console.log('')
+console.log('Package done building.')
 process.exit(0)

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Provider, State as State$1, GetProps, CreateProps, UpdateProps, DeleteProps, GetDataProps } from '@terraforge/core';
+import { Provider, State as State$1, GetProps, CreateProps, UpdateProps, DeleteProps, PlanProps, GetDataProps } from '@terraforge/core';
 
 type Property = {
     description?: string;
@@ -20,7 +20,7 @@ type Property = {
     type: 'unknown';
 });
 
-declare const generateTypes: (providers: Record<string, Property>, resources: Record<string, Property>, dataSources: Record<string, Property>) => string;
+declare const generateTypes: (namespace: string, provider: Property, resources: Record<string, Property>, dataSources: Record<string, Property>) => string;
 
 type State = Record<string, unknown>;
 type Plugin = Readonly<{
@@ -66,6 +66,11 @@ declare class TerraformProvider implements Provider {
         state: State;
     }>;
     deleteResource({ type, state }: DeleteProps): Promise<void>;
+    planResourceChange({ type, priorState, proposedState }: PlanProps): Promise<{
+        version: number;
+        requiresReplacement: boolean;
+        state: State;
+    }>;
     getData({ type, state }: GetDataProps): Promise<{
         state: State;
     }>;

package/dist/index.js

@@ -3,49 +3,56 @@ import { camelCase, pascalCase } from "change-case";
 var tab = (indent) => {
   return "	".repeat(indent);
 };
-var generateTypes = (providers, resources, dataSources) => {
+var generateTypes = (namespace, provider, resources, dataSources) => {
   return [
     generateImport("c", "@terraforge/core"),
     generateImport("t", "@terraforge/terraform"),
     "type _Record<T> = Record<string, T>",
-    generateInstallFunction(providers),
-    generateNamespace(providers, (name, prop, indent) => {
-      const typeName = name.toLowerCase();
-      return `${tab(indent)}export declare function ${typeName}(props: ${generatePropertyInputConst(prop, indent)}, config?: t.TerraformProviderConfig): t.TerraformProvider`;
-    }),
-    generateNamespace(resources, (name, prop, indent) => {
-      const typeName = pascalCase(name);
-      return [
-        // `${tab(indent)}export type ${typeName}Input = ${generatePropertyInputType(prop, indent)}`,
-        // `${tab(indent)}export type ${typeName}Output = ${generatePropertyOutputType(prop, indent)}`,
-        // `${tab(indent)}export declare const ${typeName}: ResourceClass<${typeName}Input, ${typeName}Output>`,
-        `${tab(indent)}export type ${typeName}Input = ${generatePropertyInputType(prop, indent)}`,
-        `${tab(indent)}export type ${typeName}Output = ${generatePropertyOutputType(prop, indent)}`,
-        `${tab(indent)}export class ${typeName} {`,
-        `${tab(indent + 1)}constructor(parent: c.Group, id: string, props: ${typeName}Input, config?:c.ResourceConfig)`,
-        // `${tab(indent + 1)}readonly $: c.ResourceMeta<${typeName}Input, ${typeName}Output>`,
-        generateClassProperties(prop, indent + 1),
-        `${tab(indent)}}`
-      ].join("\n\n");
-    }),
-    generateNamespace(dataSources, (name, prop, indent) => {
-      const typeName = pascalCase(name);
-      return [
-        `${tab(indent)}export type Get${typeName}Input = ${generatePropertyInputType(prop, indent)}`,
-        `${tab(indent)}export type Get${typeName}Output = ${generatePropertyOutputType(prop, indent)}`,
-        `${tab(indent)}export const get${typeName}:c.DataSourceFunction<Get${typeName}Input, Get${typeName}Output>`
-      ].join("\n\n");
-    })
+    generateInstallHelperFunctions(namespace),
+    generateProviderFactoryTypes(namespace, provider),
+    generateResourceTypes(resources),
+    generateDataSourceTypes(dataSources)
   ].join("\n\n");
 };
+var generateResourceTypes = (resources) => {
+  return generateNamespace(resources, (name, prop, indent) => {
+    const typeName = pascalCase(name);
+    return [
+      `${tab(indent)}export type ${typeName}Input = ${generatePropertyInputType(prop, indent)}`,
+      `${tab(indent)}export type ${typeName}Output = ${generatePropertyOutputType(prop, indent)}`,
+      `${tab(indent)}export class ${typeName} {`,
+      `${tab(indent + 1)}constructor(parent: c.Group, id: string, props: ${typeName}Input, config?:c.ResourceConfig)`,
+      generateClassProperties(prop, indent + 1),
+      `${tab(indent)}}`
+    ].join("\n\n");
+  });
+};
+var generateDataSourceTypes = (dataSources) => {
+  return generateNamespace(dataSources, (name, prop, indent) => {
+    const typeName = pascalCase(name);
+    return [
+      `${tab(indent)}export type Get${typeName}Input = ${generatePropertyInputType(prop, indent)}`,
+      `${tab(indent)}export type Get${typeName}Output = ${generatePropertyOutputType(prop, indent)}`,
+      `${tab(indent)}export const get${typeName}:c.DataSourceFunction<Get${typeName}Input, Get${typeName}Output>`
+    ].join("\n\n");
+  });
+};
+var generateProviderFactoryTypes = (namespace, provider) => {
+  const typeName = namespace.toLowerCase();
+  return `export declare function ${typeName}(props: ${generatePropertyInputConst(provider, 0)}, config?: t.TerraformProviderConfig): t.TerraformProvider`;
+};
 var generateImport = (name, from) => {
   return `import * as ${name} from '${from}'`;
 };
-var generateInstallFunction = (resources) => {
-  return generateNamespace(resources, (name, _prop, indent) => {
-    const typeName = name.toLowerCase();
-    return `${tab(indent)}export declare namespace ${typeName} { export function install(props?: t.InstallProps): Promise<void> }`;
-  });
+var generateInstallHelperFunctions = (namespace) => {
+  const typeName = namespace.toLowerCase();
+  return [
+    `export declare namespace ${typeName} {`,
+    `${tab(1)}export function install(props?: t.InstallProps): Promise<void>`,
+    `${tab(1)}export function uninstall(props?: t.InstallProps): Promise<void>`,
+    `${tab(1)}export function isInstalled(props?: t.InstallProps): Promise<boolean>`,
+    `}`
+  ].join("\n");
 };
 var generatePropertyInputConst = (prop, indent) => {
   return generateValue(prop, {
@@ -71,8 +78,8 @@ var generatePropertyInputType = (prop, indent) => {
 };
 var generatePropertyOutputType = (prop, indent) => {
   return generateValue(prop, {
-    indent: indent + 1,
     depth: 0,
+    indent: indent + 1,
     wrap: (v, p, ctx) => ctx.depth === 1 ? p.optional && !p.computed ? `c.OptionalOutput<${v}>` : `c.Output<${v}>` : v,
     filter: () => true,
     readonly: true,
@@ -278,6 +285,15 @@ var TerraformProvider = class {
       throw error;
     }
   }
+  async planResourceChange({ type, priorState, proposedState }) {
+    const plugin = await this.configure();
+    const result = await plugin.planResourceChange(type, priorState, proposedState);
+    return {
+      version: 0,
+      requiresReplacement: result.requiresReplace.length > 0,
+      state: result.plannedState
+    };
+  }
   async getData({ type, state }) {
     const plugin = await this.configure();
     const data = await plugin.readDataSource(type, state);
@@ -1047,9 +1063,9 @@ var createPluginClient = async (props) => {
 // src/plugin/download.ts
 import { createDebugger as createDebugger2 } from "@terraforge/core";
 import jszip from "jszip";
-import { mkdir, stat, writeFile } from "fs/promises";
+import { mkdir, rm, stat, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { join } from "path";
+import { dirname, join } from "path";
 
 // src/plugin/registry.ts
 import { arch, platform } from "os";
@@ -1136,15 +1152,33 @@ var exists = async (file) => {
 };
 var debug2 = createDebugger2("Downloader");
 var installPath = join(homedir(), ".terraforge", "plugins");
+var getInstallPath = (props) => {
+  const dir = props.location ?? installPath;
+  const file = join(dir, `${props.org}-${props.type}-${props.version}`);
+  return file;
+};
+var isPluginInstalled = (props) => {
+  return exists(getInstallPath(props));
+};
+var deletePlugin = async (props) => {
+  const file = getInstallPath(props);
+  const isAlreadyInstalled = await isPluginInstalled(props);
+  if (isAlreadyInstalled) {
+    debug2(props.type, "deleting...");
+    await rm(file);
+    debug2(props.type, "deleted");
+  } else {
+    debug2(props.type, "not installed");
+  }
+};
 var downloadPlugin = async (props) => {
   if (props.version === "latest") {
     const { latest } = await getProviderVersions(props.org, props.type);
     props.version = latest;
   }
-  const dir = props.location ?? installPath;
-  const file = join(dir, `${props.org}-${props.type}-${props.version}`);
-  const exist = await exists(file);
-  if (!exist) {
+  const file = getInstallPath(props);
+  const isAlreadyInstalled = await isPluginInstalled(props);
+  if (!isAlreadyInstalled) {
     debug2(props.type, "downloading...");
     const info = await getProviderDownloadUrl(props.org, props.type, props.version);
     const res = await fetch(info.url);
@@ -1156,7 +1190,7 @@ var downloadPlugin = async (props) => {
     }
     const binary = await zipped.async("nodebuffer");
     debug2(props.type, "done");
-    await mkdir(dir, { recursive: true });
+    await mkdir(dirname(file), { recursive: true });
     await writeFile(file, binary, {
       mode: 509
     });
@@ -1863,6 +1897,8 @@ var createClassProxy = (construct, get) => {
 var createRecursiveProxy = ({
   provider,
   install,
+  uninstall,
+  isInstalled,
   resource,
   dataSource
 }) => {
@@ -1890,6 +1926,12 @@ var createRecursiveProxy = ({
     if (key === "install") {
       return install;
     }
+    if (key === "uninstall") {
+      return uninstall;
+    }
+    if (key === "isInstalled") {
+      return isInstalled;
+    }
     return findNextProxy([], key);
   });
 };
@@ -1909,6 +1951,12 @@ var createTerraformProxy = (props) => {
     async install(installProps) {
       await downloadPlugin({ ...props.provider, ...installProps });
     },
+    async uninstall(installProps) {
+      await deletePlugin({ ...props.provider, ...installProps });
+    },
+    isInstalled(installProps) {
+      return isPluginInstalled({ ...props.provider, ...installProps });
+    },
     resource: (ns, parent, id, input, config) => {
       const type = snakeCase2([props.namespace, ...ns].join("_"));
       const provider = `terraform:${props.namespace}:${config?.provider ?? "default"}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terraforge/terraform",
-	"version": "0.0.8",
+	"version": "0.0.10",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -22,7 +22,7 @@
 	},
 	"scripts": {
 		"build": "tsup src/index.ts --format esm --dts --clean --out-dir ./dist",
-		"prepublishOnly": "bun run build",
+		"prepublishOnly": "if bun run test; then bun run build; else exit; fi",
 		"test": "bun test"
 	},
 	"peerDependencies": {