@terraforge/terraform 0.0.6 → 0.0.8

package/cli/build-package.ts

@@ -1,61 +1,64 @@
 #!/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,
-})
+const packageData = (await Bun.file('./package.json').json()) as {
+	version?: string
+	provider?: {
+		version?: Version
+		org?: string
+		type?: string
+	}
+}
 
-if (!values.org) {
-	console.error('Missing required arguments: org')
+if (!packageData || !packageData.provider) {
+	console.error('Failed to read package.json')
 	process.exit(1)
 }
 
-if (!values.type) {
-	console.error('Missing required arguments: type')
+const providerData = packageData.provider
+
+if (!providerData.version) {
+	console.error('Missing required arguments: version')
 	process.exit(1)
 }
 
-const packageData = (await Bun.file('./package.json').json()) as { version?: Version }
-
-if (!packageData) {
-	console.error('Failed to read package.json')
+if (!providerData.org) {
+	console.error('Missing required arguments: org')
 	process.exit(1)
 }
 
-if (!packageData.version) {
-	console.error('Missing required arguments: version')
+if (!providerData.type) {
+	console.error('Missing required arguments: type')
 	process.exit(1)
 }
 
-const org = values.org
-const type = values.type
-const version = packageData.version
+const org = providerData.org
+const type = providerData.type
+const version = providerData.version
 
-console.log('org:     ', org)
-console.log('type:    ', type)
-console.log('version: ', version)
+console.log('')
+console.log('Package version:  ', packageData.version)
+console.log('')
+console.log('Provider org:     ', org)
+console.log('Provider type:    ', type)
+console.log('Provider version: ', version)
+console.log('')
 
 const ok = confirm('Continue?')
 
 if (!ok) {
-	process.exit(0)
+	console.log('')
+	process.exit(1)
 }
 
 const load = createLazyPlugin({ org, type, version })
+
+console.log('')
+console.log('Loading provider plugin...')
+
 const plugin = await load()
 const schema = plugin.schema()
 const types = generateTypes(
@@ -68,17 +71,18 @@ const types = generateTypes(
 
 await plugin.stop()
 
-await Bun.write(`./src/types.ts`, types)
-
+await Bun.write(`./dist/index.d.ts`, types)
 await Bun.write(
-	`./src/index.ts`,
+	`./dist/index.js`,
 	`
 import { createTerraformAPI } from '@terraforge/terraform'
-import { root } from './types.ts'
 
-export const ${type} = createTerraformAPI<typeof root.${type}>({
+export const ${type} = createTerraformAPI({
 	namespace: '${type}',
 	provider: { org: '${org}', type: '${type}', version: '${version}' },
-}) as typeof root.${type}
+})
 `
 )
+
+console.log('Done.')
+process.exit(0)

package/dist/index.d.ts

@@ -1,23 +1,5 @@
 import { Provider, State as State$1, GetProps, CreateProps, UpdateProps, DeleteProps, GetDataProps } from '@terraforge/core';
 
-type Version = `${number}.${number}.${number}` | 'latest';
-
-type TerraformProviderConfig = {
-    id?: string;
-    location?: string;
-};
-type InstallProps = {
-    location?: string;
-};
-declare const createTerraformAPI: <T>(props: {
-    namespace: string;
-    provider: {
-        org: string;
-        type: string;
-        version: Version;
-    };
-}) => T;
-
 type Property = {
     description?: string;
     required?: boolean;
@@ -89,4 +71,22 @@ declare class TerraformProvider implements Provider {
     }>;
 }
 
-export { type InstallProps, TerraformProvider, type TerraformProviderConfig, createTerraformAPI, generateTypes };
+type Version = `${number}.${number}.${number}` | 'latest';
+
+type TerraformProviderConfig = {
+    id?: string;
+    location?: string;
+};
+type InstallProps = {
+    location?: string;
+};
+declare const createTerraformProxy: (props: {
+    namespace: string;
+    provider: {
+        org: string;
+        type: string;
+        version: Version;
+    };
+}) => () => void;
+
+export { type InstallProps, TerraformProvider, type TerraformProviderConfig, createTerraformProxy, generateTypes };

package/dist/index.js

@@ -1,3 +1,313 @@
+// src/type-gen.ts
+import { camelCase, pascalCase } from "change-case";
+var tab = (indent) => {
+  return "	".repeat(indent);
+};
+var generateTypes = (providers, 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");
+    })
+  ].join("\n\n");
+};
+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 generatePropertyInputConst = (prop, indent) => {
+  return generateValue(prop, {
+    depth: 0,
+    indent: indent + 1,
+    wrap: (v, _, ctx) => {
+      return `${v}${ctx.depth === 1 ? "," : ""}`;
+    },
+    filter: () => true,
+    optional: (p) => p.optional ?? false
+  });
+};
+var generatePropertyInputType = (prop, indent) => {
+  return generateValue(prop, {
+    depth: 0,
+    indent: indent + 1,
+    wrap: (v, p, ctx) => {
+      return ctx.depth > 0 ? p.optional ? `c.OptionalInput<${v}>` : `c.Input<${v}>` : v;
+    },
+    filter: (prop2) => !(prop2.computed && typeof prop2.optional === "undefined" && typeof prop2.required === "undefined"),
+    optional: (p) => p.optional ?? false
+  });
+};
+var generatePropertyOutputType = (prop, indent) => {
+  return generateValue(prop, {
+    indent: indent + 1,
+    depth: 0,
+    wrap: (v, p, ctx) => ctx.depth === 1 ? p.optional && !p.computed ? `c.OptionalOutput<${v}>` : `c.Output<${v}>` : v,
+    filter: () => true,
+    readonly: true,
+    // required: true,
+    optional: (p, ctx) => ctx.depth > 1 && p.optional && !p.computed || false
+  });
+};
+var generateClassProperties = (prop, indent) => {
+  if (prop.type !== "object") {
+    return "";
+  }
+  return Object.entries(prop.properties).map(([name, prop2]) => {
+    return [
+      prop2.description ? [`
+`, `	`.repeat(indent), `/** `, prop2.description.trim(), " */", "\n"].join("") : "",
+      `	`.repeat(indent),
+      "readonly ",
+      camelCase(name),
+      // ctx.optional(prop, ctx) ? '?' : '',
+      ": ",
+      generateValue(prop2, {
+        readonly: true,
+        filter: () => true,
+        optional: (p, ctx) => ctx.depth > 1 && p.optional && !p.computed || false,
+        wrap: (v, p, ctx) => {
+          return ctx.depth === 1 ? p.optional && !p.computed ? `c.OptionalOutput<${v}>` : `c.Output<${v}>` : v;
+        },
+        // ctx.depth === 1 ? `c.Output<${p.optional && !p.computed ? `${v} | undefined` : v}>` : v,
+        indent: indent + 1,
+        depth: 1
+      })
+    ].join("");
+  }).join("\n");
+};
+var groupByNamespace = (resources, minLevel, maxLevel) => {
+  const grouped = {};
+  const types = Object.keys(resources).sort();
+  for (const type of types) {
+    const names = type.split("_");
+    if (names.length < minLevel) {
+      throw new Error(`Resource not properly namespaced: ${type}`);
+    }
+    let current = grouped;
+    let count = Math.min(maxLevel, names.length - 1);
+    while (count--) {
+      const ns = camelCase(names.shift());
+      if (!current[ns]) {
+        current[ns] = {};
+      }
+      current = current[ns];
+    }
+    const name = pascalCase(names.join("_"));
+    current[name] = type;
+  }
+  return grouped;
+};
+var generateNamespace = (resources, render) => {
+  const grouped = groupByNamespace(resources, 1, 2);
+  const renderNamespace = (name, group, indent) => {
+    if (name === "default") {
+      name = "$default";
+    }
+    if (typeof group === "string") {
+      return render(name, resources[group], indent);
+    }
+    return [
+      `${tab(indent)}export ${indent === 0 ? "declare " : ""}namespace ${name.toLowerCase()} {`,
+      Object.entries(group).map(([name2, entry]) => {
+        if (typeof entry !== "string") {
+          return renderNamespace(name2, entry, indent + 1);
+        } else {
+          return render(name2, resources[entry], indent + 1);
+        }
+      }).join("\n"),
+      `${tab(indent)}}`
+    ].join("\n");
+  };
+  return Object.entries(grouped).map(([name, entry]) => {
+    return renderNamespace(name, entry, 0);
+  });
+};
+var generateValue = (prop, ctx) => {
+  if (["string", "number", "boolean", "unknown"].includes(prop.type)) {
+    return ctx.wrap(prop.type, prop, ctx);
+  }
+  if (prop.type === "array") {
+    const type = generateValue(prop.item, { ...ctx, depth: ctx.depth + 1 });
+    const array = ctx.readonly ? `ReadonlyArray<${type}>` : `Array<${type}>`;
+    return ctx.wrap(array, prop, ctx);
+  }
+  if (prop.type === "record") {
+    const type = generateValue(prop.item, { ...ctx, depth: ctx.depth + 1 });
+    const record = ctx.readonly ? `Readonly<_Record<${type}>>` : `_Record<${type}>`;
+    return ctx.wrap(record, prop, ctx);
+  }
+  if (prop.type === "object" || prop.type === "array-object") {
+    const type = [
+      "{",
+      Object.entries(prop.properties).filter(([_, p]) => ctx.filter(p)).map(
+        ([name, prop2]) => [
+          prop2.description ? [`
+`, `	`.repeat(ctx.indent), `/** `, prop2.description.trim(), " */", "\n"].join("") : "",
+          `	`.repeat(ctx.indent),
+          // ctx.readonly ? "readonly " : "",
+          camelCase(name),
+          ctx.optional(prop2, ctx) ? "?" : "",
+          ": ",
+          generateValue(prop2, { ...ctx, indent: ctx.indent + 1, depth: ctx.depth + 1 })
+        ].join("")
+      ).join("\n"),
+      `${`	`.repeat(ctx.indent - 1)}}`
+    ].join("\n");
+    const object = ctx.readonly ? `Readonly<${type}>` : type;
+    return ctx.wrap(object, prop, ctx);
+  }
+  throw new Error(`Unknown property type: ${prop.type}`);
+};
+
+// src/provider.ts
+import {
+  ResourceNotFound
+} from "@terraforge/core";
+var TerraformProvider = class {
+  constructor(type, id, createPlugin, config) {
+    this.type = type;
+    this.id = id;
+    this.createPlugin = createPlugin;
+    this.config = config;
+  }
+  configured;
+  plugin;
+  async configure() {
+    const plugin = await this.prepare();
+    if (!this.configured) {
+      this.configured = plugin.configure(this.config);
+    }
+    await this.configured;
+    return plugin;
+  }
+  prepare() {
+    if (!this.plugin) {
+      this.plugin = this.createPlugin();
+    }
+    return this.plugin;
+  }
+  async destroy() {
+    if (this.plugin) {
+      const plugin = await this.plugin;
+      plugin.stop();
+      this.plugin = void 0;
+      this.configured = void 0;
+    }
+  }
+  ownResource(id) {
+    return `terraform:${this.type}:${this.id}` === id;
+  }
+  async getResource({ type, state }) {
+    const plugin = await this.configure();
+    const newState = await plugin.readResource(type, state);
+    if (!newState) {
+      throw new ResourceNotFound();
+    }
+    return {
+      version: 0,
+      state: newState
+    };
+  }
+  async createResource({ type, state }) {
+    const plugin = await this.configure();
+    const newState = await plugin.applyResourceChange(type, null, state);
+    return {
+      version: 0,
+      state: newState
+    };
+  }
+  async updateResource({ type, priorState, proposedState }) {
+    const plugin = await this.configure();
+    const { requiresReplace } = await plugin.planResourceChange(type, priorState, proposedState);
+    if (requiresReplace.length > 0) {
+      const formattedAttrs = requiresReplace.map((p) => p.join(".")).join('", "');
+      throw new Error(
+        `Updating the "${formattedAttrs}" properties for the "${type}" resource will require the resource to be replaced.`
+      );
+    }
+    const newState = await plugin.applyResourceChange(type, priorState, proposedState);
+    return {
+      version: 0,
+      state: newState
+    };
+  }
+  async deleteResource({ type, state }) {
+    const plugin = await this.configure();
+    try {
+      await plugin.applyResourceChange(type, state, null);
+    } catch (error) {
+      try {
+        const newState = await plugin.readResource(type, state);
+        if (!newState) {
+          throw new ResourceNotFound();
+        }
+      } catch (_) {
+      }
+      throw error;
+    }
+  }
+  async getData({ type, state }) {
+    const plugin = await this.configure();
+    const data = await plugin.readDataSource(type, state);
+    if (!data) {
+      throw new Error(`Data source not found ${type}`);
+    }
+    return {
+      state: data
+    };
+  }
+  // async generateTypes(dir: string) {
+  // 	const plugin = await this.prepare()
+  // 	const schema = plugin.schema()
+  // 	const types = generateTypes(
+  // 		{
+  // 			[`${this.type}_provider`]: schema.provider,
+  // 		},
+  // 		schema.resources,
+  // 		schema.dataSources
+  // 	)
+  // 	await mkdir(dir, { recursive: true })
+  // 	await writeFile(join(dir, `${this.type}.d.ts`), types)
+  // 	await this.destroy()
+  // }
+};
+
+// src/proxy.ts
+import { createMeta, nodeMetaSymbol } from "@terraforge/core";
+import { snakeCase as snakeCase2 } from "change-case";
+
 // src/plugin/client.ts
 import { credentials, loadPackageDefinition } from "@grpc/grpc-js";
 import { fromJSON } from "@grpc/proto-loader";
@@ -1090,7 +1400,7 @@ var parseType = (type) => {
 };
 
 // src/plugin/version/util.ts
-import { camelCase, snakeCase } from "change-case";
+import { camelCase as camelCase2, snakeCase } from "change-case";
 import { pack, unpack } from "msgpackr";
 var encodeDynamicValue = (value) => {
   return {
@@ -1184,7 +1494,7 @@ var formatInputState = (schema, state, includeSchemaFields = true, path = []) =>
       const object = {};
       if (includeSchemaFields) {
         for (const [key, prop] of Object.entries(schema.properties)) {
-          const value = state[camelCase(key)];
+          const value = state[camelCase2(key)];
           object[key] = formatInputState(prop, value, true, [...path, key]);
         }
       } else {
@@ -1229,7 +1539,7 @@ var formatOutputState = (schema, state, path = []) => {
       const object = {};
       for (const [key, prop] of Object.entries(schema.properties)) {
         const value = state[key];
-        object[camelCase(key)] = formatOutputState(prop, value, [...path, key]);
+        object[camelCase2(key)] = formatOutputState(prop, value, [...path, key]);
       }
       return object;
     }
@@ -1241,7 +1551,7 @@ var formatOutputState = (schema, state, path = []) => {
         const object = {};
         for (const [key, prop] of Object.entries(schema.properties)) {
           const value = state[0][key];
-          object[camelCase(key)] = formatOutputState(prop, value, [...path, key]);
+          object[camelCase2(key)] = formatOutputState(prop, value, [...path, key]);
         }
         return object;
       } else {
@@ -1474,133 +1784,37 @@ var retry = async (tries, cb) => {
   throw latestError;
 };
 
-// src/provider.ts
-import {
-  ResourceNotFound
-} from "@terraforge/core";
-var TerraformProvider = class {
-  constructor(type, id, createPlugin, config) {
-    this.type = type;
-    this.id = id;
-    this.createPlugin = createPlugin;
-    this.config = config;
-  }
-  configured;
-  plugin;
-  async configure() {
-    const plugin = await this.prepare();
-    if (!this.configured) {
-      this.configured = plugin.configure(this.config);
-    }
-    await this.configured;
-    return plugin;
-  }
-  prepare() {
-    if (!this.plugin) {
-      this.plugin = this.createPlugin();
-    }
-    return this.plugin;
-  }
-  async destroy() {
-    if (this.plugin) {
-      const plugin = await this.plugin;
-      plugin.stop();
-      this.plugin = void 0;
-      this.configured = void 0;
-    }
-  }
-  ownResource(id) {
-    return `terraform:${this.type}:${this.id}` === id;
-  }
-  async getResource({ type, state }) {
-    const plugin = await this.configure();
-    const newState = await plugin.readResource(type, state);
-    if (!newState) {
-      throw new ResourceNotFound();
-    }
-    return {
-      version: 0,
-      state: newState
-    };
-  }
-  async createResource({ type, state }) {
-    const plugin = await this.configure();
-    const newState = await plugin.applyResourceChange(type, null, state);
-    return {
-      version: 0,
-      state: newState
-    };
-  }
-  async updateResource({ type, priorState, proposedState }) {
-    const plugin = await this.configure();
-    const { requiresReplace } = await plugin.planResourceChange(type, priorState, proposedState);
-    if (requiresReplace.length > 0) {
-      const formattedAttrs = requiresReplace.map((p) => p.join(".")).join('", "');
-      throw new Error(
-        `Updating the "${formattedAttrs}" properties for the "${type}" resource will require the resource to be replaced.`
-      );
-    }
-    const newState = await plugin.applyResourceChange(type, priorState, proposedState);
-    return {
-      version: 0,
-      state: newState
-    };
-  }
-  async deleteResource({ type, state }) {
-    const plugin = await this.configure();
-    try {
-      await plugin.applyResourceChange(type, state, null);
-    } catch (error) {
-      try {
-        const newState = await plugin.readResource(type, state);
-        if (!newState) {
-          throw new ResourceNotFound();
+// src/proxy.ts
+var createResourceProxy = (cb) => {
+  return new Proxy(
+    {},
+    {
+      get(_, key) {
+        return cb(key);
+      },
+      set(_, key) {
+        if (typeof key === "string") {
+          throw new Error(`Cannot set property ${key} on read-only object.`);
         }
-      } catch (_) {
-      }
-      throw error;
-    }
-  }
-  async getData({ type, state }) {
-    const plugin = await this.configure();
-    const data = await plugin.readDataSource(type, state);
-    if (!data) {
-      throw new Error(`Data source not found ${type}`);
-    }
-    return {
-      state: data
-    };
-  }
-  // async generateTypes(dir: string) {
-  // 	const plugin = await this.prepare()
-  // 	const schema = plugin.schema()
-  // 	const types = generateTypes(
-  // 		{
-  // 			[`${this.type}_provider`]: schema.provider,
-  // 		},
-  // 		schema.resources,
-  // 		schema.dataSources
-  // 	)
-  // 	await mkdir(dir, { recursive: true })
-  // 	await writeFile(join(dir, `${this.type}.d.ts`), types)
-  // 	await this.destroy()
-  // }
+        throw new Error(`This object is read-only.`);
+      }
+    }
+  );
 };
-
-// src/resource.ts
-import { createMeta, nodeMetaSymbol } from "@terraforge/core";
-import { snakeCase as snakeCase2 } from "change-case";
-var createNamespaceProxy = (cb, scb) => {
+var createNamespaceProxy = (cb) => {
   const cache = /* @__PURE__ */ new Map();
   return new Proxy(
     {},
     {
       get(_, key) {
-        if (!cache.has(key)) {
-          const value = typeof key === "symbol" ? scb?.(key) : cb(key);
-          cache.set(key, value);
+        if (typeof key === "string") {
+          if (!cache.has(key)) {
+            const value = cb(key);
+            cache.set(key, value);
+          }
+          return cache.get(key);
         }
-        return cache.get(key);
+        return;
       },
       set(_, key) {
         if (typeof key === "string") {
@@ -1611,6 +1825,25 @@ var createNamespaceProxy = (cb, scb) => {
     }
   );
 };
+var createRootProxy = (apply, get) => {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(() => {
+  }, {
+    apply(_, _this, args) {
+      return apply(...args);
+    },
+    get(_, key) {
+      if (typeof key === "string") {
+        if (!cache.has(key)) {
+          const value = get(key);
+          cache.set(key, value);
+        }
+        return cache.get(key);
+      }
+      return;
+    }
+  });
+};
 var createClassProxy = (construct, get) => {
   return new Proxy(class {
   }, {
@@ -1628,307 +1861,88 @@ var createClassProxy = (construct, get) => {
   });
 };
 var createRecursiveProxy = ({
+  provider,
+  install,
   resource,
   dataSource
 }) => {
-  const createProxy = (names) => {
-    return createNamespaceProxy((name) => {
-      const ns = [...names, name];
-      if (name === name.toLowerCase()) {
-        return createProxy(ns);
-      } else if (name.startsWith("get")) {
-        return (...args) => {
-          return dataSource([...names, name.substring(3)], ...args);
-        };
-      } else {
-        return createClassProxy(
-          (...args) => {
-            return resource(ns, ...args);
-          },
-          (...args) => {
-            return dataSource(ns, ...args);
-          }
-        );
-      }
-    });
+  const findNextProxy = (ns, name) => {
+    if (name === name.toLowerCase()) {
+      return createNamespaceProxy((key) => {
+        return findNextProxy([...ns, name], key);
+      });
+    } else if (name.startsWith("get")) {
+      return (...args) => {
+        return dataSource([...ns, name.substring(3)], ...args);
+      };
+    } else {
+      return createClassProxy(
+        (...args) => {
+          return resource([...ns, name], ...args);
+        },
+        (...args) => {
+          return dataSource([...ns, name], ...args);
+        }
+      );
+    }
   };
-  return createProxy([]);
+  return createRootProxy(provider, (key) => {
+    if (key === "install") {
+      return install;
+    }
+    return findNextProxy([], key);
+  });
 };
-var createResourceProxy = (name) => {
+var createTerraformProxy = (props) => {
   return createRecursiveProxy({
+    provider(input, config) {
+      return new TerraformProvider(
+        props.namespace,
+        config?.id ?? "default",
+        createLazyPlugin({
+          ...props.provider,
+          location: config?.location
+        }),
+        input
+      );
+    },
+    async install(installProps) {
+      await downloadPlugin({ ...props.provider, ...installProps });
+    },
     resource: (ns, parent, id, input, config) => {
-      const type = snakeCase2(name + "_" + ns.join("_"));
-      const provider = `terraform:${name}:${config?.provider ?? "default"}`;
+      const type = snakeCase2([props.namespace, ...ns].join("_"));
+      const provider = `terraform:${props.namespace}:${config?.provider ?? "default"}`;
       const meta = createMeta("resource", provider, parent, type, id, input, config);
-      const resource = createNamespaceProxy(
-        (key) => {
+      const resource = createResourceProxy((key) => {
+        if (typeof key === "string") {
           return meta.output((data) => data[key]);
-        },
-        (key) => {
-          if (key === nodeMetaSymbol) {
-            return meta;
-          }
-          return;
+        } else if (key === nodeMetaSymbol) {
+          return meta;
         }
-      );
+        return;
+      });
       parent.add(resource);
       return resource;
     },
-    // external: (ns: string[], id: string, input: State, config?: ResourceConfig) => {
-    // 	const type = snakeCase(ns.join('_'))
-    // 	const provider = `terraform:${ns[0]}:${config?.provider ?? 'default'}`
-    // 	const $ = createResourceMeta(provider, type, id, input, config)
-    // 	const resource = createNamespaceProxy(
-    // 		key => {
-    // 			if (key === '$') {
-    // 				return $
-    // 			}
-    // 			return $.output(data => data[key])
-    // 		},
-    // 		{ $ }
-    // 	) as Resource
-    // 	parent.add(resource)
-    // 	return resource
-    // },
-    // (ns: string[], parent: Group, id: string, input: State, config?: ResourceConfig)
     dataSource: (ns, parent, id, input, config) => {
-      const type = snakeCase2(name + "_" + ns.join("_"));
-      const provider = `terraform:${name}:${config?.provider ?? "default"}`;
+      const type = snakeCase2([props.namespace, ...ns].join("_"));
+      const provider = `terraform:${props.namespace}:${config?.provider ?? "default"}`;
       const meta = createMeta("data", provider, parent, type, id, input, config);
-      const dataSource = createNamespaceProxy(
-        (key) => {
+      const dataSource = createResourceProxy((key) => {
+        if (typeof key === "string") {
           return meta.output((data) => data[key]);
-        },
-        (key) => {
-          if (key === nodeMetaSymbol) {
-            return meta;
-          }
-          return;
+        } else if (key === nodeMetaSymbol) {
+          return meta;
         }
-      );
+        return;
+      });
       parent.add(dataSource);
       return dataSource;
     }
   });
 };
-
-// src/api.ts
-var createTerraformAPI = (props) => {
-  const resource = createResourceProxy(props.namespace);
-  const install = async (installProps) => {
-    await downloadPlugin({ ...props.provider, ...installProps });
-  };
-  const createPlugin = (pluginProps) => {
-    return createLazyPlugin({ ...props.provider, ...pluginProps });
-  };
-  return new Proxy(() => {
-  }, {
-    apply(_, _this, [input, config]) {
-      return new TerraformProvider(
-        props.namespace,
-        config?.id ?? "default",
-        createPlugin({ location: config?.location }),
-        input
-      );
-    },
-    get(_, prop) {
-      if (prop === "install") {
-        return install;
-      }
-      return resource;
-    }
-  });
-};
-
-// src/type-gen.ts
-import { camelCase as camelCase2, pascalCase } from "change-case";
-var tab = (indent) => {
-  return "	".repeat(indent);
-};
-var generateTypes = (providers, 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 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");
-    })
-  ].join("\n\n");
-};
-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 namespace ${typeName} { export function install(props?: t.InstallProps): Promise<void> }`;
-  });
-};
-var generatePropertyInputConst = (prop, indent) => {
-  return generateValue(prop, {
-    depth: 0,
-    indent: indent + 1,
-    wrap: (v, _, ctx) => {
-      return `${v}${ctx.depth === 1 ? "," : ""}`;
-    },
-    filter: () => true,
-    optional: (p) => p.optional ?? false
-  });
-};
-var generatePropertyInputType = (prop, indent) => {
-  return generateValue(prop, {
-    depth: 0,
-    indent: indent + 1,
-    wrap: (v, p, ctx) => {
-      return ctx.depth > 0 ? p.optional ? `c.OptionalInput<${v}>` : `c.Input<${v}>` : v;
-    },
-    filter: (prop2) => !(prop2.computed && typeof prop2.optional === "undefined" && typeof prop2.required === "undefined"),
-    optional: (p) => p.optional ?? false
-  });
-};
-var generatePropertyOutputType = (prop, indent) => {
-  return generateValue(prop, {
-    indent: indent + 1,
-    depth: 0,
-    wrap: (v, p, ctx) => ctx.depth === 1 ? p.optional && !p.computed ? `c.OptionalOutput<${v}>` : `c.Output<${v}>` : v,
-    filter: () => true,
-    readonly: true,
-    // required: true,
-    optional: (p, ctx) => ctx.depth > 1 && p.optional && !p.computed || false
-  });
-};
-var generateClassProperties = (prop, indent) => {
-  if (prop.type !== "object") {
-    return "";
-  }
-  return Object.entries(prop.properties).map(([name, prop2]) => {
-    return [
-      prop2.description ? [`
-`, `	`.repeat(indent), `/** `, prop2.description.trim(), " */", "\n"].join("") : "",
-      `	`.repeat(indent),
-      "readonly ",
-      camelCase2(name),
-      // ctx.optional(prop, ctx) ? '?' : '',
-      ": ",
-      generateValue(prop2, {
-        readonly: true,
-        filter: () => true,
-        optional: (p, ctx) => ctx.depth > 1 && p.optional && !p.computed || false,
-        wrap: (v, p, ctx) => {
-          return ctx.depth === 1 ? p.optional && !p.computed ? `c.OptionalOutput<${v}>` : `c.Output<${v}>` : v;
-        },
-        // ctx.depth === 1 ? `c.Output<${p.optional && !p.computed ? `${v} | undefined` : v}>` : v,
-        indent: indent + 1,
-        depth: 1
-      })
-    ].join("");
-  }).join("\n");
-};
-var groupByNamespace = (resources, minLevel, maxLevel) => {
-  const grouped = {};
-  const types = Object.keys(resources).sort();
-  for (const type of types) {
-    const names = type.split("_");
-    if (names.length < minLevel) {
-      throw new Error(`Resource not properly namespaced: ${type}`);
-    }
-    let current = grouped;
-    let count = Math.min(maxLevel, names.length - 1);
-    while (count--) {
-      const ns = camelCase2(names.shift());
-      if (!current[ns]) {
-        current[ns] = {};
-      }
-      current = current[ns];
-    }
-    const name = pascalCase(names.join("_"));
-    current[name] = type;
-  }
-  return grouped;
-};
-var generateNamespace = (resources, render) => {
-  const grouped = groupByNamespace(resources, 1, 2);
-  const renderNamespace = (name, group, indent) => {
-    if (name === "default") {
-      name = "$default";
-    }
-    return [
-      `${tab(indent)}export ${indent === 0 ? "declare " : ""}namespace ${name.toLowerCase()} {`,
-      Object.entries(group).map(([name2, entry]) => {
-        if (typeof entry !== "string") {
-          return renderNamespace(name2, entry, indent + 1);
-        } else {
-          return render(name2, resources[entry], indent + 1);
-        }
-      }).join("\n"),
-      `${tab(indent)}}`
-    ].join("\n");
-  };
-  return renderNamespace("root", grouped, 0);
-};
-var generateValue = (prop, ctx) => {
-  if (["string", "number", "boolean", "unknown"].includes(prop.type)) {
-    return ctx.wrap(prop.type, prop, ctx);
-  }
-  if (prop.type === "array") {
-    const type = generateValue(prop.item, { ...ctx, depth: ctx.depth + 1 });
-    const array = ctx.readonly ? `ReadonlyArray<${type}>` : `Array<${type}>`;
-    return ctx.wrap(array, prop, ctx);
-  }
-  if (prop.type === "record") {
-    const type = generateValue(prop.item, { ...ctx, depth: ctx.depth + 1 });
-    const record = ctx.readonly ? `Readonly<_Record<${type}>>` : `_Record<${type}>`;
-    return ctx.wrap(record, prop, ctx);
-  }
-  if (prop.type === "object" || prop.type === "array-object") {
-    const type = [
-      "{",
-      Object.entries(prop.properties).filter(([_, p]) => ctx.filter(p)).map(
-        ([name, prop2]) => [
-          prop2.description ? [`
-`, `	`.repeat(ctx.indent), `/** `, prop2.description.trim(), " */", "\n"].join("") : "",
-          `	`.repeat(ctx.indent),
-          // ctx.readonly ? "readonly " : "",
-          camelCase2(name),
-          ctx.optional(prop2, ctx) ? "?" : "",
-          ": ",
-          generateValue(prop2, { ...ctx, indent: ctx.indent + 1, depth: ctx.depth + 1 })
-        ].join("")
-      ).join("\n"),
-      `${`	`.repeat(ctx.indent - 1)}}`
-    ].join("\n");
-    const object = ctx.readonly ? `Readonly<${type}>` : type;
-    return ctx.wrap(object, prop, ctx);
-  }
-  throw new Error(`Unknown property type: ${prop.type}`);
-};
 export {
   TerraformProvider,
-  createTerraformAPI,
+  createTerraformProxy,
   generateTypes
 };

package/package.json

@@ -1,7 +1,14 @@
 {
 	"name": "@terraforge/terraform",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/terraforge-js/terraforge.git"
+	},
+	"bugs": {
+		"url": "https://github.com/terraforge-js/terraforge/issues"
+	},
 	"module": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"bin": {
@@ -19,7 +26,7 @@
 		"test": "bun test"
 	},
 	"peerDependencies": {
-		"@terraforge/core": "0.0.4"
+		"@terraforge/core": "0.0.5"
 	},
 	"dependencies": {
 		"@grpc/grpc-js": "1.12.6",