@sdlcworks/components 0.0.7 → 0.0.9

package/dist/index.d.ts

@@ -19,94 +19,189 @@ export declare enum CloudProvider {
 	cloudflare = "cloudflare"
 }
 export declare enum DeploymentArtifactType {
-	container_image = "container_image",
-	local_file = "local_file"
+	container_image = "container_image"
 }
-export type CommonPulumiFnInputs = {
-	componentName: string;
-	$: {
-		(name: string, ...values: any[]): string;
-		(strings: TemplateStringsArray, ...values: any[]): string;
+/**
+ * Abstract base class for defining connection interfaces.
+ * Users extend this class to define the schema for data that
+ * connecting components must provide.
+ */
+export declare abstract class ConnectionInterface<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> {
+	abstract readonly schema: TSchema;
+}
+/**
+ * Factory function to create a ConnectionInterface class from a schema.
+ * Avoids boilerplate of defining a class manually.
+ *
+ * @example
+ * const TriggerConnection = createConnectionInterface(
+ *   z.object({ eventSource: z.string() })
+ * );
+ */
+export declare function createConnectionInterface<TSchema extends z.ZodObject<z.ZodRawShape>>(schema: TSchema): {
+	new (): {
+		readonly schema: TSchema;
 	};
 };
-export type CommonDeployFnInputs<T = undefined> = Record<string, {
-	provisionOutput: InfraComponentOutput;
-	deploymentConfig: T;
-	deploymentArtifact: {
-		uri: string;
-		type: DeploymentArtifactType;
-	};
-}>;
+/**
+ * Type alias for ConnectionInterface class constructors.
+ */
+export type ConnectionInterfaceClass<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = new () => ConnectionInterface<TSchema>;
+/**
+ * Extract the inferred data type from a ConnectionInterface class.
+ */
+export type InferConnectionData<C extends ConnectionInterfaceClass> = z.infer<InstanceType<C>["schema"]>;
+/**
+ * Wrap connection data with PulumiInput to support Pulumi Output types.
+ */
+export type InferConnectionDataWithInputs<C extends ConnectionInterfaceClass> = {
+	[K in keyof InferConnectionData<C>]: PulumiInput<InferConnectionData<C>[K]>;
+};
+/**
+ * Entry type for allowConnectionInterfaces parameter.
+ * Declares an interface that this component exposes with typed data.
+ */
+export type AllowedConnectionInterfaceEntry<C extends ConnectionInterfaceClass = ConnectionInterfaceClass> = {
+	interface: C;
+	data: InferConnectionDataWithInputs<C>;
+};
+/**
+ * Function type for allowConnectionInterfaces.
+ * Called within pulumi function to declare exposed connection interfaces.
+ */
+export type AllowConnectionInterfacesFn = <C extends ConnectionInterfaceClass>(entries: AllowedConnectionInterfaceEntry<C>[]) => void;
 export type InferZodType<S extends z.ZodRawShape> = {
 	[K in keyof z.infer<z.ZodObject<S>>]: PulumiInput<z.infer<z.ZodObject<S>>[K]>;
 };
-export type InfraComponentOpts<CShape extends z.ZodRawShape, DShape extends z.ZodRawShape> = {
-	metadata: {
-		stateful: boolean;
-		proxiable: boolean;
-		require_connector_same_provider: boolean;
-	};
-	connectionTypes: Record<string, {
-		description: string;
-	}>;
+export type InferOutputType<OShape extends z.ZodRawShape> = {
+	[K in keyof z.infer<z.ZodObject<OShape>>]: PulumiOutput<z.infer<z.ZodObject<OShape>>[K]>;
+};
+declare const emptyOutputSchema: z.ZodObject<{}, z.core.$strip>;
+export type EmptyOutputShape = typeof emptyOutputSchema.shape;
+declare const InfraComponentOptsSchema: z.ZodObject<{
+	metadata: z.ZodObject<{
+		stateful: z.ZodBoolean;
+		proxiable: z.ZodBoolean;
+	}, z.core.$strip>;
+	connectionTypes: z.ZodRecord<z.ZodString, z.ZodObject<{
+		description: z.ZodString;
+	}, z.core.$strip>>;
+	configSchema: z.ZodCustom<z.ZodObject<Readonly<{
+		[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}>, z.core.$strip>, z.ZodObject<Readonly<{
+		[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}>, z.core.$strip>>;
+	deploymentInputSchema: z.ZodCustom<z.ZodObject<Readonly<{
+		[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}>, z.core.$strip>, z.ZodObject<Readonly<{
+		[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}>, z.core.$strip>>;
+	outputSchema: z.ZodCustom<z.ZodObject<Readonly<{
+		[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}>, z.core.$strip>, z.ZodObject<Readonly<{
+		[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}>, z.core.$strip>>;
+}, z.core.$strip>;
+export type InfraComponentOptsBase = z.infer<typeof InfraComponentOptsSchema>;
+export type InfraComponentOpts<CShape extends z.ZodRawShape, DShape extends z.ZodRawShape, OShape extends z.ZodRawShape, ConnTypes extends Record<string, {
+	description: string;
+}> = Record<string, {
+	description: string;
+}>> = Omit<InfraComponentOptsBase, "configSchema" | "deploymentInputSchema" | "outputSchema" | "connectionTypes"> & {
 	configSchema: z.ZodObject<CShape>;
 	deploymentInputSchema: z.ZodObject<DShape>;
+	outputSchema: z.ZodObject<OShape>;
+	connectionTypes: ConnTypes;
 };
 export type InfraComponentInputs<C, D> = {
 	config: C;
 	deploymentInput: D;
 };
-export type InfraComponentOutputs = {
-	[key: string]: PulumiOutput<any>;
-};
-export type ProviderPulumiCtx<I, S> = CommonPulumiFnInputs & {
+export type ProviderPulumiCtx<I, S> = {
+	componentName: string;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
 	inputs: I;
 	state: S;
+	allowConnectionInterfaces: AllowConnectionInterfacesFn;
 };
-export type ProviderConnectCtx<S> = {
+/**
+ * Context passed to connection handlers.
+ * Contains the provider state, typed data from the connecting component,
+ * and the connection type chosen by the orchestrator.
+ */
+export type ConnectionHandlerCtx<S, Data, ConnectionType extends string = string> = {
 	state: S;
+	data: Data;
+	connectionType: ConnectionType;
 };
-export type ProviderDeployCtx<S> = CommonDeployFnInputs & {
-	state: S;
+/**
+ * A connection handler entry mapping a ConnectionInterface to its handler function.
+ */
+export type ConnectionHandlerEntry<S, ConnectionType extends string, C extends ConnectionInterfaceClass = ConnectionInterfaceClass> = {
+	interface: C;
+	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<C>, ConnectionType>) => Promise<void>;
 };
-export type ProviderPulumiFn<I, S> = (ctx: ProviderPulumiCtx<I, S>) => Promise<InfraComponentOutputs>;
-export type ProviderConnectFn<S> = (ctx: ProviderConnectCtx<S>) => Promise<void>;
-export type ProviderDeployFn<S> = (ctx: ProviderDeployCtx<S>) => Promise<void>;
+export type ProviderDeployCtx<D, S> = {
+	state: S;
+} & Record<string, {
+	provisionOutput: InfraComponentOutput;
+	deploymentConfig: D;
+	deploymentArtifact: {
+		uri: string;
+		type: DeploymentArtifactType;
+	};
+}>;
+export type ProviderPulumiFn<I, S, O> = (ctx: ProviderPulumiCtx<I, S>) => Promise<O>;
+export type ProviderDeployFn<D, S> = (ctx: ProviderDeployCtx<D, S>) => Promise<void>;
 declare const emptyStateSchema: z.ZodObject<{}, z.core.$strip>;
 export type EmptyStateShape = typeof emptyStateSchema.shape;
-export type ProviderFnsDefStateless<I> = {
-	stateSchema?: never;
-	pulumi: ProviderPulumiFn<I, Record<string, never>>;
-	onConnect?: ProviderConnectFn<Record<string, never>>;
-	onDeploy?: ProviderDeployFn<Record<string, never>>;
-};
-export type ProviderFnsDefStateful<I, SShape extends z.ZodRawShape> = {
-	stateSchema: z.ZodObject<SShape>;
-	pulumi: ProviderPulumiFn<I, z.infer<z.ZodObject<SShape>>>;
-	onConnect?: ProviderConnectFn<z.infer<z.ZodObject<SShape>>>;
-	onDeploy?: ProviderDeployFn<z.infer<z.ZodObject<SShape>>>;
+export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateShape, ConnectionType extends string = string> = {
+	stateSchema?: z.ZodObject<SShape>;
+	pulumi: ProviderPulumiFn<I, z.infer<z.ZodObject<SShape>>, O>;
+	connect?: ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType>[];
+	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
 };
-export type ProviderFnsDef<I, SShape extends z.ZodRawShape = EmptyStateShape> = ProviderFnsDefStateless<I> | ProviderFnsDefStateful<I, SShape>;
 export type StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
-	pulumi: ProviderPulumiFn<any, any>;
-	onConnect?: ProviderConnectFn<any>;
-	onDeploy?: ProviderDeployFn<any>;
+	pulumi: ProviderPulumiFn<any, any, any>;
+	connect?: ConnectionHandlerEntry<any, any>[];
+	deploy?: ProviderDeployFn<any, any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
-export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends z.ZodRawShape> {
-	opts: InfraComponentOpts<CShape, DShape>;
+export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends z.ZodRawShape, OShape extends z.ZodRawShape = EmptyOutputShape, ConnTypes extends Record<string, {
+	description: string;
+}> = Record<string, {
+	description: string;
+}>> {
+	opts: InfraComponentOpts<CShape, DShape, OShape, ConnTypes>;
 	providers: ProviderRegistry;
 	validationSchema: z.ZodTypeAny;
 	validationDeploymentInputSchema: z.ZodTypeAny;
-	constructor(opts: InfraComponentOpts<CShape, DShape>);
-	private register;
-	aws<SShape extends z.ZodRawShape = EmptyStateShape>(fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, SShape>): void;
-	gcloud<SShape extends z.ZodRawShape = EmptyStateShape>(fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, SShape>): void;
-	azure<SShape extends z.ZodRawShape = EmptyStateShape>(fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, SShape>): void;
-	linode<SShape extends z.ZodRawShape = EmptyStateShape>(fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, SShape>): void;
-	hetzner<SShape extends z.ZodRawShape = EmptyStateShape>(fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, SShape>): void;
-	cloudflare<SShape extends z.ZodRawShape = EmptyStateShape>(fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, SShape>): void;
+	private allowedInterfaces;
+	constructor(opts: InfraComponentOpts<CShape, DShape, OShape, ConnTypes>);
+	implement<SShape extends z.ZodRawShape = EmptyStateShape>(provider: CloudProvider, fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, InferZodType<DShape>, InferOutputType<OShape>, SShape, keyof ConnTypes & string>): this;
+	/**
+	 * Get the schema for a specific connection interface.
+	 * Used by the orchestrator at runtime.
+	 */
+	getConnectionSchema(interfaceClass: ConnectionInterfaceClass): z.ZodObject<z.ZodRawShape> | undefined;
+	/**
+	 * Create the allowConnectionInterfaces function for use in pulumi context.
+	 * The orchestrator calls this before invoking the pulumi function.
+	 *
+	 * @returns Function that validates and stores allowed connection interfaces
+	 */
+	createAllowConnectionInterfacesFn(): AllowConnectionInterfacesFn;
+	/**
+	 * Get the allowed connection interfaces that were declared via allowConnectionInterfaces.
+	 * The orchestrator calls this after the pulumi function completes.
+	 *
+	 * @returns Map of interface classes to their data, or null if not set
+	 */
+	getAllowedInterfaces(): Map<ConnectionInterfaceClass, any> | null;
 }
 
 export {};

package/dist/index.js

@@ -1 +1 @@
-import{z as q}from"zod";import*as H from"@pulumi/pulumi";var J;((B)=>{B.aws="aws";B.gcloud="gcloud";B.azure="azure";B.linode="linode";B.hetzner="hetzner";B.cloudflare="cloudflare"})(J||={});var K;((F)=>{F.container_image="container_image";F.local_file="local_file"})(K||={});function E(j){if(j instanceof q.ZodObject){let x=j.shape,F={};for(let G in x)F[G]=E(x[G]);return q.object(F)}if(j instanceof q.ZodOptional)return E(j.unwrap()).optional();if(j instanceof q.ZodNullable)return E(j.unwrap()).nullable();if(j instanceof q.ZodArray)return q.array(E(j.element));return q.union([j,q.custom((x)=>H.Output.isInstance(x))])}var L=q.object({metadata:q.object({stateful:q.boolean(),proxiable:q.boolean(),require_connector_same_provider:q.boolean()}),connectionTypes:q.record(q.string(),q.object({description:q.string().min(5)})),configSchema:q.any(),deploymentInputSchema:q.any()}),M=q.object({});class N{opts;providers;validationSchema;validationDeploymentInputSchema;constructor(j){this.opts=L.parse(j),this.providers={},this.validationSchema=E(j.configSchema),this.validationDeploymentInputSchema=E(j.deploymentInputSchema)}register(j,x){this.providers[j]={...x,stateSchema:x.stateSchema??M}}aws(j){this.register("aws",j)}gcloud(j){this.register("gcloud",j)}azure(j){this.register("azure",j)}linode(j){this.register("linode",j)}hetzner(j){this.register("hetzner",j)}cloudflare(j){this.register("cloudflare",j)}}export{N as InfraComponent,K as DeploymentArtifactType,J as CloudProvider};
+import{z as x}from"zod";import*as H from"@pulumi/pulumi";var J;((j)=>{j.aws="aws";j.gcloud="gcloud";j.azure="azure";j.linode="linode";j.hetzner="hetzner";j.cloudflare="cloudflare"})(J||={});var W=x.enum(J),L;((g)=>g.container_image="container_image")(L||={});class K{}function X(b){return class extends K{schema=b}}var Y=x.object({});function q(b){if(b instanceof x.ZodObject){let g=b.shape,B={};for(let E in g)B[E]=q(g[E]);return x.object(B)}if(b instanceof x.ZodOptional)return q(b.unwrap()).optional();if(b instanceof x.ZodNullable)return q(b.unwrap()).nullable();if(b instanceof x.ZodArray)return x.array(q(b.element));return x.union([b,x.custom((g)=>H.Output.isInstance(g))])}var N=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()}),Q=x.object({});class U{opts;providers;validationSchema;validationDeploymentInputSchema;allowedInterfaces=null;constructor(b){this.opts=N.parse(b),this.providers={},this.validationSchema=q(b.configSchema),this.validationDeploymentInputSchema=q(b.deploymentInputSchema)}implement(b,g){return this.providers[b]={...g,stateSchema:g.stateSchema??Q},this}getConnectionSchema(b){return new b().schema}createAllowConnectionInterfacesFn(){return(b)=>{if(!this.allowedInterfaces)this.allowedInterfaces=new Map;for(let g of b){let F=new g.interface().schema.safeParse(g.data);if(!F.success)throw new Error(`Invalid data for connection interface ${g.interface.name}: ${F.error.message}`);this.allowedInterfaces.set(g.interface,g.data)}}}getAllowedInterfaces(){return this.allowedInterfaces}}export{X as createConnectionInterface,U as InfraComponent,L as DeploymentArtifactType,K as ConnectionInterface,J as CloudProvider};

package/package.json

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