@terraforge/terraform 0.0.9 → 0.0.11

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

@@ -65,18 +65,39 @@ 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`,
 	`
@@ -89,5 +110,6 @@ export const ${type} = createTerraformProxy({
 `
 )
 
-console.log('Done.')
+console.log('')
+console.log('Package done building.')
 process.exit(0)

package/dist/index.d.mts

@@ -0,0 +1,310 @@
+//#region src/plugin/schema.d.ts
+
+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';
+});
+//#endregion
+//#region src/type-gen.d.ts
+declare const generateTypes: (namespace: string, provider: Property, resources: Record<string, Property>, dataSources: Record<string, Property>) => string;
+//#endregion
+//#region src/plugin/version/type.d.ts
+type State$1 = Record<string, unknown>;
+type Plugin = Readonly<{
+  schema: () => {
+    provider: Property;
+    resources: Record<string, Property>;
+    dataSources: Record<string, Property>;
+  };
+  stop: () => Promise<void>;
+  configure: (config: State$1) => Promise<void>;
+  readResource: (type: string, state: State$1) => Promise<State$1>;
+  readDataSource: (type: string, state: State$1) => Promise<State$1>;
+  validateResource: (type: string, state: State$1) => Promise<void>;
+  planResourceChange: (type: string, priorState: State$1 | null, proposedNewState: State$1 | null) => Promise<{
+    requiresReplace: Array<string | number>[];
+    plannedState: State$1;
+  }>;
+  applyResourceChange: (type: string, priorState: State$1 | null, proposedNewState: State$1 | null) => Promise<State$1>;
+}>;
+//#endregion
+//#region ../core/src/future.d.ts
+declare class Future<T = unknown> {
+  protected callback: (resolve: (data: T) => void, reject: (error: unknown) => void) => void;
+  protected listeners: Set<{
+    resolve: (data: T) => void;
+    reject?: (error: unknown) => void;
+  }>;
+  protected status: 0 | 1 | 2 | 3;
+  protected data?: T;
+  protected error?: unknown;
+  constructor(callback: (resolve: (data: T) => void, reject: (error: unknown) => void) => void);
+  get [Symbol.toStringTag](): string;
+  pipe<N>(cb: (value: T) => N): Future<Awaited<N>>;
+  then(resolve: (data: T) => void, reject?: (error: unknown) => void): void;
+}
+//#endregion
+//#region ../core/src/input.d.ts
+type Input<T = unknown> = T | Output<T> | Future<T> | Promise<T>;
+type UnwrapInputArray<T extends Input[]> = { [K in keyof T]: UnwrapInput<T[K]> };
+type UnwrapInput<T> = T extends Input<infer V> ? V : T;
+//#endregion
+//#region ../core/src/output.d.ts
+declare class Output<T = unknown> extends Future<T> {
+  readonly dependencies: Set<Meta>;
+  constructor(dependencies: Set<Meta>, callback: (resolve: (data: T) => void, reject: (error: unknown) => void) => void);
+  pipe<N>(cb: (value: T) => N): Output<Awaited<N>>;
+}
+declare const combine: <T extends Input[], R = UnwrapInputArray<T>>(...inputs: T) => Output<R>;
+declare const resolve: <T extends [Input, ...Input[]], R>(inputs: T, transformer: (...inputs: UnwrapInputArray<T>) => R) => Output<Awaited<R>>;
+declare const interpolate: (literals: TemplateStringsArray, ...placeholders: Input<any>[]) => Output<string>;
+//#endregion
+//#region ../core/src/urn.d.ts
+type URN = `urn:${string}`;
+//#endregion
+//#region ../core/src/node.d.ts
+declare const nodeMetaSymbol: unique symbol;
+type Node<T extends Tag = Tag, O extends State = State> = {
+  readonly [nodeMetaSymbol]: Meta<T>;
+  readonly urn: URN;
+} & O;
+//#endregion
+//#region ../core/src/resource.d.ts
+type ResourceConfig = Config & {
+  /** Import an existing resource instead of creating a new resource. */
+  import?: string;
+  /** If true the resource will be retained in the backing cloud provider during a delete operation. */
+  retainOnDelete?: boolean;
+  /** If set, the provider’s Delete method will not be called for this resource if the specified resource is being deleted as well. */
+  /** Declare that changes to certain properties should be treated as forcing a replacement. */
+  replaceOnChanges?: string[];
+  /** If true, create the replacement before deleting the existing resource. */
+  createBeforeReplace?: boolean;
+};
+type ResourceMeta = Meta<'resource', ResourceConfig>;
+type Resource<O extends State = State> = O & {
+  readonly [nodeMetaSymbol]: ResourceMeta;
+  readonly urn: URN;
+};
+//#endregion
+//#region ../core/src/stack.d.ts
+declare class Stack extends Group {
+  readonly app: App;
+  readonly dependencies: Set<Stack>;
+  constructor(app: App, name: string);
+  dependsOn(...stacks: Stack[]): this;
+}
+//#endregion
+//#region ../core/src/meta.d.ts
+type Tag = 'resource' | 'data';
+type State = Record<string, any>;
+type Config = {
+  /** Specify additional explicit dependencies in addition to the ones in the dependency graph. */
+  dependsOn?: Resource[];
+  /** Pass an ID of an explicitly configured provider, instead of using the default provider. */
+  provider?: string;
+};
+type Meta<T extends Tag = Tag, C extends Config = Config> = {
+  readonly tag: T;
+  readonly urn: URN;
+  readonly logicalId: string;
+  readonly type: string;
+  readonly stack: Stack;
+  readonly provider: string;
+  readonly input: State;
+  readonly config?: C;
+  readonly dependencies: Set<URN>;
+  readonly resolve: (data: State) => void;
+  readonly output: <V>(cb: (data: State) => V) => Output<V>;
+};
+//#endregion
+//#region ../core/src/data-source.d.ts
+type DataSourceMeta = Meta<'data'>;
+type DataSource<O extends State = State> = {
+  readonly [nodeMetaSymbol]: DataSourceMeta;
+  readonly urn: URN;
+} & O;
+//#endregion
+//#region ../core/src/group.d.ts
+declare class Group {
+  readonly parent: Group | undefined;
+  readonly type: string;
+  readonly name: string;
+  protected children: Array<Group | Node>;
+  constructor(parent: Group | undefined, type: string, name: string);
+  get urn(): URN;
+  protected addChild(child: Group | Node): void;
+  add(...children: Array<Group | Node>): void;
+  get nodes(): Node[];
+  get resources(): Resource[];
+  get dataSources(): DataSource[];
+}
+//#endregion
+//#region ../core/src/app.d.ts
+declare class App extends Group {
+  readonly name: string;
+  constructor(name: string);
+  get stacks(): Stack[];
+}
+//#endregion
+//#region ../core/src/provider.d.ts
+type CreateProps<T = State> = {
+  type: string;
+  state: T;
+  idempotantToken?: string;
+};
+type UpdateProps<T = State> = {
+  type: string;
+  priorState: T;
+  proposedState: T;
+  idempotantToken?: string;
+};
+type DeleteProps<T = State> = {
+  type: string;
+  state: T;
+  idempotantToken?: string;
+};
+type PlanProps<T = State> = {
+  type: string;
+  priorState: T;
+  proposedState: T;
+};
+type GetProps<T = State> = {
+  type: string;
+  state: T;
+};
+type GetDataProps<T = State> = {
+  type: string;
+  state: T;
+};
+interface Provider {
+  ownResource(id: string): boolean;
+  getResource(props: GetProps): Promise<{
+    version: number;
+    state: State;
+  }>;
+  createResource(props: CreateProps): Promise<{
+    version: number;
+    state: State;
+  }>;
+  updateResource(props: UpdateProps): Promise<{
+    version: number;
+    state: State;
+  }>;
+  deleteResource(props: DeleteProps): Promise<void>;
+  planResourceChange?(props: PlanProps): Promise<{
+    version: number;
+    state: State;
+    requiresReplacement: boolean;
+  }>;
+  getData?(props: GetDataProps): Promise<{
+    state: State;
+  }>;
+  destroy?(): Promise<void>;
+}
+//#endregion
+//#region ../core/src/helpers.d.ts
+declare const file: (path: string, encoding?: BufferEncoding) => Future<string>;
+declare const hash: (path: string, algo?: string) => Future<string>;
+//#endregion
+//#region ../core/src/globals.d.ts
+declare global {
+  var $resolve: typeof resolve;
+  var $combine: typeof combine;
+  var $interpolate: typeof interpolate;
+  var $hash: typeof hash;
+  var $file: typeof file;
+}
+//#endregion
+//#region src/provider.d.ts
+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: State);
+  private configure;
+  private prepare;
+  destroy(): Promise<void>;
+  ownResource(id: string): boolean;
+  getResource({
+    type,
+    state
+  }: GetProps): Promise<{
+    version: number;
+    state: State$1;
+  }>;
+  createResource({
+    type,
+    state
+  }: CreateProps): Promise<{
+    version: number;
+    state: State$1;
+  }>;
+  updateResource({
+    type,
+    priorState,
+    proposedState
+  }: UpdateProps): Promise<{
+    version: number;
+    state: State$1;
+  }>;
+  deleteResource({
+    type,
+    state
+  }: DeleteProps): Promise<void>;
+  planResourceChange({
+    type,
+    priorState,
+    proposedState
+  }: PlanProps): Promise<{
+    version: number;
+    requiresReplacement: boolean;
+    state: State$1;
+  }>;
+  getData({
+    type,
+    state
+  }: GetDataProps): Promise<{
+    state: State$1;
+  }>;
+}
+//#endregion
+//#region src/plugin/registry.d.ts
+type Version = `${number}.${number}.${number}` | 'latest';
+//#endregion
+//#region src/proxy.d.ts
+type TerraformProviderConfig = {
+  id?: string;
+  location?: string;
+};
+type InstallProps = {
+  location?: string;
+};
+declare const createTerraformProxy: (props: {
+  namespace: string;
+  provider: {
+    org: string;
+    type: string;
+    version: Version;
+  };
+}) => () => void;
+//#endregion
+export { type InstallProps, TerraformProvider, type TerraformProviderConfig, createTerraformProxy, generateTypes };