@sdlcworks/components 0.0.8 → 0.0.9

package/dist/index.d.ts

@@ -19,24 +19,57 @@ 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]>;
 };
@@ -70,57 +103,105 @@ declare const InfraComponentOptsSchema: z.ZodObject<{
 	}>, 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> = Omit<InfraComponentOptsBase, "configSchema" | "deploymentInputSchema" | "outputSchema"> & {
+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 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 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 ProviderConnectFn<S> = (ctx: ProviderConnectCtx<S>) => Promise<void>;
-export type ProviderDeployFn<S> = (ctx: ProviderDeployCtx<S>) => Promise<void>;
+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, O> = {
-	stateSchema?: never;
-	pulumi: ProviderPulumiFn<I, Record<string, never>, O>;
-	onConnect?: ProviderConnectFn<Record<string, never>>;
-	onDeploy?: ProviderDeployFn<Record<string, never>>;
-};
-export type ProviderFnsDefStateful<I, O, SShape extends z.ZodRawShape> = {
-	stateSchema: 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>;
-	onConnect?: ProviderConnectFn<z.infer<z.ZodObject<SShape>>>;
-	onDeploy?: ProviderDeployFn<z.infer<z.ZodObject<SShape>>>;
+	connect?: ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType>[];
+	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
 };
-export type ProviderFnsDef<I, O, SShape extends z.ZodRawShape = EmptyStateShape> = ProviderFnsDefStateless<I, O> | ProviderFnsDefStateful<I, O, SShape>;
 export type StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
 	pulumi: ProviderPulumiFn<any, any, any>;
-	onConnect?: ProviderConnectFn<any>;
-	onDeploy?: ProviderDeployFn<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, OShape extends z.ZodRawShape = EmptyOutputShape> {
-	opts: InfraComponentOpts<CShape, DShape, OShape>;
+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, OShape>);
-	implement<SShape extends z.ZodRawShape = EmptyStateShape>(provider: CloudProvider, fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>, InferZodType<DShape>>, InferOutputType<OShape>, SShape>): this;
+	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,80 +1 @@
-// 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 CloudProviderSchema = z.enum(CloudProvider);
-var DeploymentArtifactType;
-((DeploymentArtifactType2) => {
-  DeploymentArtifactType2["container_image"] = "container_image";
-  DeploymentArtifactType2["local_file"] = "local_file";
-})(DeploymentArtifactType ||= {});
-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()
-});
-var emptyStateSchema = z.object({});
-
-class InfraComponent {
-  opts;
-  providers;
-  validationSchema;
-  validationDeploymentInputSchema;
-  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
-    };
-    return this;
-  }
-}
-export {
-  InfraComponent,
-  DeploymentArtifactType,
-  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.8",
+  "version": "0.0.9",
   "module": "dist/index.js",
   "files": [
     "dist"