@sdlcworks/components 0.0.19 → 0.0.20

package/dist/index.d.ts

@@ -156,6 +156,12 @@ export type InfraComponentOpts<CShape extends z.ZodRawShape, DShape extends z.Zo
 	connectionTypes: ConnTypes;
 };
 export type InfraComponentInputs<C> = C;
+export type ArtifactInfo = {
+	artifact: {
+		uri: string;
+		type: DeploymentArtifactType;
+	};
+};
 export type DeploymentInfo = {
 	config: Record<string, any>;
 	artifact: {
@@ -172,7 +178,7 @@ export type ProviderPulumiCtx<I, S> = {
 	inputs: I;
 	state: S;
 	declareConnectionInterfaces: DeclareConnectionInterfacesFn;
-	buildArtifacts: Record<string, DeploymentInfo>;
+	buildArtifacts: Record<string, ArtifactInfo>;
 };
 /**
  * Context passed to connection handlers.
@@ -186,11 +192,9 @@ export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string
 };
 /**
  * Result returned by connection handlers.
- * Handlers can optionally return a URI for the connection.
+ * Maps component names to their URIs, or void if no URIs need to be returned.
  */
-export type ConnectionHandlerResult = {
-	uri?: PulumiOutput<string>;
-};
+export type ConnectionHandlerResult = Record<string, PulumiOutput<string>> | void;
 /**
  * A connection handler entry mapping a ConnectionInterface to its handler function.
  */
@@ -208,15 +212,44 @@ export declare function connectionHandler<C extends ConnectionInterfaceClass>(en
 export type ProviderDeployCtx<D, S> = {
 	state: S;
 } & Record<string, DeploymentInfo>;
+export type ProviderAllocateCtx<S> = {
+	name: string;
+	deploymentConfig: Record<string, any>;
+	state: S;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
+};
+export type ProviderDeallocateCtx<S> = {
+	name: string;
+	deploymentConfig: Record<string, any>;
+	state: S;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
+};
+export type ProviderUpsertArtifactsCtx<S> = {
+	buildArtifacts: Record<string, ArtifactInfo>;
+	state: S;
+};
 export type ProviderPulumiFn<I, S, O> = (ctx: ProviderPulumiCtx<I, S>) => Promise<O>;
 export type ProviderDeployFn<D, S> = (ctx: ProviderDeployCtx<D, S>) => Promise<void>;
+export type ProviderAllocateFn<S> = (ctx: ProviderAllocateCtx<S>) => Promise<void>;
+export type ProviderDeallocateFn<S> = (ctx: ProviderDeallocateCtx<S>) => Promise<void>;
+export type ProviderUpsertArtifactsFn<S> = (ctx: ProviderUpsertArtifactsCtx<S>) => Promise<void>;
 declare const emptyStateSchema: z.ZodObject<{}, z.core.$strip>;
 export type EmptyStateShape = typeof emptyStateSchema.shape;
 export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateShape, ConnectionType extends string = string> = {
 	stateSchema?: z.ZodObject<SShape>;
+	initialState?: z.infer<z.ZodObject<SShape>>;
 	pulumi: ProviderPulumiFn<I, z.infer<z.ZodObject<SShape>>, O>;
 	connect?: readonly ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType, any>[];
 	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
+	allocateComponent?: ProviderAllocateFn<z.infer<z.ZodObject<SShape>>>;
+	deallocateComponent?: ProviderDeallocateFn<z.infer<z.ZodObject<SShape>>>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<z.infer<z.ZodObject<SShape>>>;
 };
 /**
  * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceClass type.
@@ -229,9 +262,13 @@ export type StoredConnectionHandlerEntry = {
 };
 export type StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
+	initialState?: any;
 	pulumi: ProviderPulumiFn<any, any, any>;
 	connect?: readonly StoredConnectionHandlerEntry[];
 	deploy?: ProviderDeployFn<any, any>;
+	allocateComponent?: ProviderAllocateFn<any>;
+	deallocateComponent?: ProviderDeallocateFn<any>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
 export type DeclaredConnectionInterfaces = Map<ConnectionInterfaceClass, any>;

package/dist/index.js

@@ -1 +1,137 @@
-import{z as x}from"zod";import*as K from"@pulumi/pulumi";var M;((B)=>{B.aws="aws";B.gcloud="gcloud";B.azure="azure";B.linode="linode";B.hetzner="hetzner";B.cloudflare="cloudflare"})(M||={});var L;((q)=>{q.ipv4="ipv4";q.ipv6="ipv6";q.domain="domain"})(L||={});var N;((j)=>j.container_image="container_image")(N||={});class H{}function Q(b){return class extends H{schema=b}}function Z(b,j){let q=new b().schema.merge(j);return class extends H{schema=q}}var _=Q(x.object({url:x.object({type:x.nativeEnum(L),value:x.string()}),publicAccess:x.boolean()})),$=x.object({});function E(b){if(b instanceof x.ZodObject){let j=b.shape,F={};for(let q in j)F[q]=E(j[q]);return x.object(F)}if(b instanceof x.ZodOptional)return E(b.unwrap()).optional();if(b instanceof x.ZodNullable)return E(b.unwrap()).nullable();if(b instanceof x.ZodArray)return x.array(E(b.element));return x.union([b,x.custom((j)=>K.Output.isInstance(j))])}var V=x.object({metadata:x.object({stateful:x.boolean(),proxiable:x.boolean()}),connectionTypes:x.record(x.string(),x.object({description:x.string().min(5)})),configSchema:x.custom(),deploymentInputSchema:x.custom(),outputSchema:x.custom()});function g(b){return b}var W=x.object({});class X{opts;providers;validationSchema;validationDeploymentInputSchema;declaredConnectionInterfaces=new Map;constructor(b){this.opts=V.parse(b),this.providers={},this.validationSchema=E(b.configSchema),this.validationDeploymentInputSchema=E(b.deploymentInputSchema)}implement(b,j){return this.providers[b]={...j,stateSchema:j.stateSchema??W},this}getConnectionSchema(b){return new b().schema}createDeclareConnectionInterfacesFn(){return(b)=>{for(let j of b){let J=new j.interface().schema.safeParse(j.data);if(!J.success)throw new Error(`Invalid data for connection interface ${j.interface.name}: ${J.error.message}`);this.declaredConnectionInterfaces.set(j.interface,j.data)}}}getDeclaredInterfaces(){return this.declaredConnectionInterfaces}}export{Z as extendConnectionInterface,Q as createConnectionInterface,g as connectionHandler,L as TCPUrlType,_ as TCPCI,X as InfraComponent,N as DeploymentArtifactType,H as ConnectionInterface,M as CloudProvider};
+// src/infra.ts
+import { z } from "zod";
+import * as pulumi from "@pulumi/pulumi";
+var CloudProvider;
+((CloudProvider2) => {
+  CloudProvider2["aws"] = "aws";
+  CloudProvider2["gcloud"] = "gcloud";
+  CloudProvider2["azure"] = "azure";
+  CloudProvider2["linode"] = "linode";
+  CloudProvider2["hetzner"] = "hetzner";
+  CloudProvider2["cloudflare"] = "cloudflare";
+})(CloudProvider ||= {});
+var TCPUrlType;
+((TCPUrlType2) => {
+  TCPUrlType2["ipv4"] = "ipv4";
+  TCPUrlType2["ipv6"] = "ipv6";
+  TCPUrlType2["domain"] = "domain";
+})(TCPUrlType ||= {});
+var DeploymentArtifactType;
+((DeploymentArtifactType2) => {
+  DeploymentArtifactType2["container_image"] = "container_image";
+})(DeploymentArtifactType ||= {});
+
+class ConnectionInterface {
+}
+function createConnectionInterface(schema) {
+  return class extends ConnectionInterface {
+    schema = schema;
+  };
+}
+function extendConnectionInterface(parentClass, additionalSchema) {
+  const parentInstance = new parentClass;
+  const mergedSchema = parentInstance.schema.merge(additionalSchema);
+  return class extends ConnectionInterface {
+    schema = mergedSchema;
+  };
+}
+var TCPCI = createConnectionInterface(z.object({
+  url: z.object({
+    type: z.nativeEnum(TCPUrlType),
+    value: z.string()
+  }),
+  publicAccess: z.boolean()
+}));
+var emptyOutputSchema = z.object({});
+function transformSchemaToAcceptOutputs(schema) {
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    const newShape = {};
+    for (const key in shape) {
+      newShape[key] = transformSchemaToAcceptOutputs(shape[key]);
+    }
+    return z.object(newShape);
+  }
+  if (schema instanceof z.ZodOptional) {
+    return transformSchemaToAcceptOutputs(schema.unwrap()).optional();
+  }
+  if (schema instanceof z.ZodNullable) {
+    return transformSchemaToAcceptOutputs(schema.unwrap()).nullable();
+  }
+  if (schema instanceof z.ZodArray) {
+    return z.array(transformSchemaToAcceptOutputs(schema.element));
+  }
+  return z.union([
+    schema,
+    z.custom((val) => pulumi.Output.isInstance(val))
+  ]);
+}
+var InfraComponentOptsSchema = z.object({
+  metadata: z.object({
+    stateful: z.boolean(),
+    proxiable: z.boolean()
+  }),
+  connectionTypes: z.record(z.string(), z.object({
+    description: z.string().min(5)
+  })),
+  configSchema: z.custom(),
+  deploymentInputSchema: z.custom(),
+  outputSchema: z.custom()
+});
+function connectionHandler(entry) {
+  return entry;
+}
+var emptyStateSchema = z.object({});
+
+class InfraComponent {
+  opts;
+  providers;
+  validationSchema;
+  validationDeploymentInputSchema;
+  declaredConnectionInterfaces = new Map;
+  constructor(opts) {
+    this.opts = InfraComponentOptsSchema.parse(opts);
+    this.providers = {};
+    this.validationSchema = transformSchemaToAcceptOutputs(opts.configSchema);
+    this.validationDeploymentInputSchema = transformSchemaToAcceptOutputs(opts.deploymentInputSchema);
+  }
+  implement(provider, fns) {
+    this.providers[provider] = {
+      ...fns,
+      stateSchema: fns.stateSchema ?? emptyStateSchema,
+      initialState: fns.initialState
+    };
+    return this;
+  }
+  getConnectionSchema(interfaceClass) {
+    const instance = new interfaceClass;
+    return instance.schema;
+  }
+  createDeclareConnectionInterfacesFn() {
+    return (entries) => {
+      for (const entry of entries) {
+        const instance = new entry.interface;
+        const schema = instance.schema;
+        const parseResult = schema.safeParse(entry.data);
+        if (!parseResult.success) {
+          throw new Error(`Invalid data for connection interface ${entry.interface.name}: ${parseResult.error.message}`);
+        }
+        this.declaredConnectionInterfaces.set(entry.interface, entry.data);
+      }
+    };
+  }
+  getDeclaredInterfaces() {
+    return this.declaredConnectionInterfaces;
+  }
+}
+export {
+  extendConnectionInterface,
+  createConnectionInterface,
+  connectionHandler,
+  TCPUrlType,
+  TCPCI,
+  InfraComponent,
+  DeploymentArtifactType,
+  ConnectionInterface,
+  CloudProvider
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdlcworks/components",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "module": "dist/index.js",
   "files": [
     "dist"