@sdlcworks/components 0.0.9 → 0.0.13

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 {
+export enum CloudProvider {
 	aws = "aws",
 	gcloud = "gcloud",
 	azure = "azure",
@@ -58,18 +51,18 @@ export type InferConnectionDataWithInputs<C extends ConnectionInterfaceClass> =
 	[K in keyof InferConnectionData<C>]: PulumiInput<InferConnectionData<C>[K]>;
 };
 /**
- * Entry type for allowConnectionInterfaces parameter.
+ * Entry type for declareConnectionInterfaces parameter.
  * Declares an interface that this component exposes with typed data.
  */
-export type AllowedConnectionInterfaceEntry<C extends ConnectionInterfaceClass = ConnectionInterfaceClass> = {
+export type DeclaredConnectionInterfaceEntry<C extends ConnectionInterfaceClass = ConnectionInterfaceClass> = {
 	interface: C;
 	data: InferConnectionDataWithInputs<C>;
 };
 /**
- * Function type for allowConnectionInterfaces.
+ * Function type for declareConnectionInterfaces.
  * Called within pulumi function to declare exposed connection interfaces.
  */
-export type AllowConnectionInterfacesFn = <C extends ConnectionInterfaceClass>(entries: AllowedConnectionInterfaceEntry<C>[]) => void;
+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]>;
 };
@@ -117,6 +110,13 @@ export type InfraComponentInputs<C, D> = {
 	config: C;
 	deploymentInput: D;
 };
+export type DeploymentInfo = {
+	config: Record<string, any>;
+	artifact: {
+		uri: string;
+		type: DeploymentArtifactType;
+	};
+};
 export type ProviderPulumiCtx<I, S> = {
 	componentName: string;
 	$: {
@@ -125,35 +125,36 @@ export type ProviderPulumiCtx<I, S> = {
 	};
 	inputs: I;
 	state: S;
-	allowConnectionInterfaces: AllowConnectionInterfacesFn;
+	declareConnectionInterfaces: DeclareConnectionInterfacesFn;
+	buildArtifacts: Record<string, DeploymentInfo>;
 };
 /**
  * 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> = {
+export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string = string> = {
 	state: S;
-	data: Data;
+	connectionData: ConnectorData;
 	connectionType: ConnectionType;
 };
+/**
+ * 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 = ConnectionInterfaceClass> = {
+export type ConnectionHandlerEntry<S, ConnectionType extends string, C extends ConnectionInterfaceClass> = {
 	interface: C;
-	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<C>, ConnectionType>) => Promise<void>;
+	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;
-	};
-}>;
+} & Record<string, DeploymentInfo>;
 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>;
@@ -161,16 +162,26 @@ 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>;
 	pulumi: ProviderPulumiFn<I, z.infer<z.ZodObject<SShape>>, O>;
-	connect?: ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType>[];
+	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 StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
 	pulumi: ProviderPulumiFn<any, any, any>;
-	connect?: ConnectionHandlerEntry<any, any>[];
+	connect?: readonly StoredConnectionHandlerEntry[];
 	deploy?: ProviderDeployFn<any, any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
+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, {
@@ -180,7 +191,7 @@ export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends
 	providers: ProviderRegistry;
 	validationSchema: z.ZodTypeAny;
 	validationDeploymentInputSchema: z.ZodTypeAny;
-	private allowedInterfaces;
+	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;
 	/**
@@ -189,19 +200,17 @@ export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends
 	 */
 	getConnectionSchema(interfaceClass: ConnectionInterfaceClass): z.ZodObject<z.ZodRawShape> | undefined;
 	/**
-	 * Create the allowConnectionInterfaces function for use in pulumi context.
+	 * Create the declareConnectionInterfaces function for use in pulumi context.
 	 * The orchestrator calls this before invoking the pulumi function.
 	 *
-	 * @returns Function that validates and stores allowed connection interfaces
+	 * @returns Function that validates and stores declared connection interfaces
 	 */
-	createAllowConnectionInterfacesFn(): AllowConnectionInterfacesFn;
+	createDeclareConnectionInterfacesFn(): DeclareConnectionInterfacesFn;
 	/**
-	 * Get the allowed connection interfaces that were declared via allowConnectionInterfaces.
+	 * Get the declared connection interfaces that were declared via declareConnectionInterfaces.
 	 * 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;
+	getDeclaredInterfaces(): DeclaredConnectionInterfaces;
 }
 
 export {};

package/dist/index.js

@@ -1 +1,101 @@
-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};
+// src/infra.ts
+import { z } from "zod";
+import * as pulumi from "@pulumi/pulumi";
+import { CloudProvider } from "@sdlc/types";
+var DeploymentArtifactType;
+((DeploymentArtifactType2) => {
+  DeploymentArtifactType2["container_image"] = "container_image";
+})(DeploymentArtifactType ||= {});
+
+class ConnectionInterface {
+}
+function createConnectionInterface(schema) {
+  return class extends ConnectionInterface {
+    schema = schema;
+  };
+}
+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;
+  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
+    };
+    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,
+  ConnectionInterface,
+  CloudProvider
+};

package/package.json

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