@sdlcworks/components 0.0.8 → 0.0.12

package/dist/index.d.ts

@@ -3,14 +3,7 @@
 import { Input as PulumiInput, Output as PulumiOutput } from '@pulumi/pulumi';
 import { z } from 'zod';
 
-declare const InfraComponentOutputSchema = z.object({
-	service_name: z.string().nullable().optional(),
-	public_url: z.string().nullable().optional(),
-	env_outputs: z.array(z.string()).default([]),
-	resource_urns: z.array(z.string()),
-});
-export type InfraComponentOutput = z.infer<typeof InfraComponentOutputSchema>;
-export declare enum CloudProvider {
+declare enum CloudProvider {
 	aws = "aws",
 	gcloud = "gcloud",
 	azure = "azure",
@@ -18,25 +11,65 @@ export declare enum CloudProvider {
 	hetzner = "hetzner",
 	cloudflare = "cloudflare"
 }
+declare const InfraComponentOutputSchema = z.object({
+	service_name: z.string().nullable().optional(),
+	public_url: z.string().nullable().optional(),
+	env_outputs: z.array(z.string()).default([]),
+	resource_urns: z.array(z.string()),
+});
+export type InfraComponentOutput = z.infer<typeof InfraComponentOutputSchema>;
 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 declareConnectionInterfaces parameter.
+ * Declares an interface that this component exposes with typed data.
+ */
+export type DeclaredConnectionInterfaceEntry<C extends ConnectionInterfaceClass = ConnectionInterfaceClass> = {
+	interface: C;
+	data: InferConnectionDataWithInputs<C>;
+};
+/**
+ * Function type for declareConnectionInterfaces.
+ * Called within pulumi function to declare exposed connection interfaces.
+ */
+export type DeclareConnectionInterfacesFn = <C extends ConnectionInterfaceClass>(entries: DeclaredConnectionInterfaceEntry<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,120 @@ 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;
+	declareConnectionInterfaces: DeclareConnectionInterfacesFn;
 };
-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, ConnectorData, ConnectionType extends string = string> = {
 	state: S;
+	connectionData: ConnectorData;
+	connectionType: ConnectionType;
 };
-export type ProviderDeployCtx<S> = CommonDeployFnInputs & {
-	state: S;
+/**
+ * Result returned by connection handlers.
+ * Handlers can optionally return a URI for the connection.
+ */
+export type ConnectionHandlerResult = {
+	uri?: PulumiOutput<string>;
 };
+/**
+ * A connection handler entry mapping a ConnectionInterface to its handler function.
+ */
+export type ConnectionHandlerEntry<S, ConnectionType extends string, C extends ConnectionInterfaceClass> = {
+	interface: C;
+	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<C>, ConnectionType>) => Promise<ConnectionHandlerResult>;
+};
+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?: readonly ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType, any>[];
+	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
+};
+/**
+ * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceClass type.
+ * This ensures `interface` is always typed as ConnectionInterfaceClass (not any)
+ * when accessing from the registry, allowing runtime schema access.
+ */
+export type StoredConnectionHandlerEntry = {
+	interface: ConnectionInterfaceClass;
+	handler: (ctx: ConnectionHandlerCtx<any, any, any>) => Promise<ConnectionHandlerResult>;
 };
-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?: readonly StoredConnectionHandlerEntry[];
+	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 type DeclaredConnectionInterfaces = Map<ConnectionInterfaceClass, any>;
+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 declaredConnectionInterfaces;
+	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 declareConnectionInterfaces function for use in pulumi context.
+	 * The orchestrator calls this before invoking the pulumi function.
+	 *
+	 * @returns Function that validates and stores declared connection interfaces
+	 */
+	createDeclareConnectionInterfacesFn(): DeclareConnectionInterfacesFn;
+	/**
+	 * Get the declared connection interfaces that were declared via declareConnectionInterfaces.
+	 * The orchestrator calls this after the pulumi function completes.
+	 */
+	getDeclaredInterfaces(): DeclaredConnectionInterfaces;
 }
 
 export {};

package/dist/index.js

@@ -1,21 +1,18 @@
 // 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 ||= {});
+
+class ConnectionInterface {
+}
+function createConnectionInterface(schema) {
+  return class extends ConnectionInterface {
+    schema = schema;
+  };
+}
 var emptyOutputSchema = z.object({});
 function transformSchemaToAcceptOutputs(schema) {
   if (schema instanceof z.ZodObject) {
@@ -59,6 +56,7 @@ class InfraComponent {
   providers;
   validationSchema;
   validationDeploymentInputSchema;
+  declaredConnectionInterfaces = new Map;
   constructor(opts) {
     this.opts = InfraComponentOptsSchema.parse(opts);
     this.providers = {};
@@ -72,9 +70,30 @@ class InfraComponent {
     };
     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 {
+  createConnectionInterface,
   InfraComponent,
   DeploymentArtifactType,
-  CloudProvider
+  ConnectionInterface
 };

package/package.json

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