@sdlcworks/components 0.0.26 → 0.0.28

package/dist/index.d.ts

@@ -3,6 +3,25 @@
 import { Input as PulumiInput, Output as PulumiOutput } from '@pulumi/pulumi';
 import { z } from 'zod';
 
+declare const BranchMetadataCloudCredentialGCPSchema = z.object({
+	GCP_PROJECT_ID: z.string().describe("Required GCP Project ID"),
+	GCP_SERVICE_ACCOUNT_KEY: z.string()
+		.describe("Required GCP Service Account Key"),
+});
+export type BranchMetadataCloudCredentialGCP = z.infer<typeof BranchMetadataCloudCredentialGCPSchema>;
+declare const BranchMetadataCloudCredentialAWSSchema = z.object({
+	AWS_ACCESS_KEY_ID: z.string().describe("Required AWS Access Key ID"),
+	AWS_SECRET_ACCESS_KEY: z.string().describe("Required AWS Secret Access Key"),
+	AWS_REGION: z.string().describe("Required AWS Region"),
+});
+export type BranchMetadataCloudCredentialAWS = z.infer<typeof BranchMetadataCloudCredentialAWSSchema>;
+declare const BranchMetadataCloudCredentialCloudflareSchema = z.object({
+	CLOUDFLARE_API_TOKEN: z.string().describe("Required Cloudflare API Token"),
+	CLOUDFLARE_ACCOUNT_ID: z.string()
+		.optional()
+		.describe("Optional Cloudflare Account ID (required for account-scoped resources like Workers, R2, Pages)"),
+});
+export type BranchMetadataCloudCredentialCloudflare = z.infer<typeof BranchMetadataCloudCredentialCloudflareSchema>;
 export declare enum CloudProvider {
 	aws = "aws",
 	gcloud = "gcloud",
@@ -11,6 +30,23 @@ export declare enum CloudProvider {
 	hetzner = "hetzner",
 	cloudflare = "cloudflare"
 }
+/**
+ * Maps each CloudProvider to its corresponding credential type.
+ * Used to provide fully-typed credentials in handler contexts.
+ */
+export type ProviderCredentialsMap = {
+	[CloudProvider.gcloud]: BranchMetadataCloudCredentialGCP;
+	[CloudProvider.aws]: BranchMetadataCloudCredentialAWS;
+	[CloudProvider.cloudflare]: BranchMetadataCloudCredentialCloudflare;
+	[CloudProvider.azure]: Record<string, unknown>;
+	[CloudProvider.linode]: Record<string, unknown>;
+	[CloudProvider.hetzner]: Record<string, unknown>;
+};
+/**
+ * Function type for getCredentials.
+ * Returns the typed credentials for the specified provider.
+ */
+export type GetCredentialsFn<P extends CloudProvider> = () => ProviderCredentialsMap[P];
 export declare enum TCPUrlType {
 	ipv4 = "ipv4",
 	ipv6 = "ipv6",
@@ -161,7 +197,7 @@ export type DeploymentInfo = {
 		type: DeploymentArtifactType;
 	};
 };
-export type ProviderPulumiCtx<I, S> = {
+export type ProviderPulumiCtx<I, S, P extends CloudProvider = CloudProvider> = {
 	componentName: string;
 	$: {
 		(name: string, ...values: any[]): string;
@@ -171,16 +207,18 @@ export type ProviderPulumiCtx<I, S> = {
 	state: S;
 	declareConnectionInterfaces: DeclareConnectionInterfacesFn;
 	buildArtifacts: Record<string, ArtifactInfo>;
+	getCredentials: GetCredentialsFn<P>;
 };
 /**
  * Context passed to connection handlers.
  * Contains the provider state, typed data from the connecting component,
- * and the connection type chosen by the orchestrator.
+ * the connection type chosen by the orchestrator, and getCredentials function.
  */
-export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string = string> = {
+export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string = string, P extends CloudProvider = CloudProvider> = {
 	state: S;
 	connectionData: ConnectorData;
 	connectionType: ConnectionType;
+	getCredentials: GetCredentialsFn<P>;
 };
 /**
  * Result returned by connection handlers.
@@ -190,9 +228,9 @@ export type ConnectionHandlerResult = Record<string, PulumiOutput<string>>;
 /**
  * A connection handler entry mapping a ConnectionInterfaceDef to its handler function.
  */
-export type ConnectionHandlerEntry<S, ConnectionType extends string, D extends ConnectionInterfaceDef> = {
+export type ConnectionHandlerEntry<S, ConnectionType extends string, D extends ConnectionInterfaceDef, P extends CloudProvider = CloudProvider> = {
 	interface: D;
-	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<D>, ConnectionType>) => Promise<ConnectionHandlerResult>;
+	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<D>, ConnectionType, P>) => Promise<ConnectionHandlerResult>;
 };
 /**
  * Type definition for a connection handler entry.
@@ -203,10 +241,11 @@ export type ConnectionHandlerDef<D extends ConnectionInterfaceDef> = {
 	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<D>, any>) => Promise<ConnectionHandlerResult>;
 };
 export declare function connectionHandler<D extends ConnectionInterfaceDef>(entry: ConnectionHandlerDef<D>): ConnectionHandlerDef<D>;
-export type ProviderDeployCtx<D, S> = {
+export type ProviderDeployCtx<D, S, P extends CloudProvider = CloudProvider> = {
 	state: S;
+	getCredentials: GetCredentialsFn<P>;
 } & Record<string, DeploymentInfo>;
-export type ProviderAllocateCtx<S> = {
+export type ProviderAllocateCtx<S, P extends CloudProvider = CloudProvider> = {
 	name: string;
 	deploymentConfig: Record<string, any>;
 	state: S;
@@ -214,8 +253,9 @@ export type ProviderAllocateCtx<S> = {
 		(name: string, ...values: any[]): string;
 		(strings: TemplateStringsArray, ...values: any[]): string;
 	};
+	getCredentials: GetCredentialsFn<P>;
 };
-export type ProviderDeallocateCtx<S> = {
+export type ProviderDeallocateCtx<S, P extends CloudProvider = CloudProvider> = {
 	name: string;
 	deploymentConfig: Record<string, any>;
 	state: S;
@@ -223,16 +263,18 @@ export type ProviderDeallocateCtx<S> = {
 		(name: string, ...values: any[]): string;
 		(strings: TemplateStringsArray, ...values: any[]): string;
 	};
+	getCredentials: GetCredentialsFn<P>;
 };
-export type ProviderUpsertArtifactsCtx<S> = {
+export type ProviderUpsertArtifactsCtx<S, P extends CloudProvider = CloudProvider> = {
 	buildArtifacts: Record<string, ArtifactInfo>;
 	state: S;
+	getCredentials: GetCredentialsFn<P>;
 };
-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>;
+export type ProviderPulumiFn<I, S, O, P extends CloudProvider = CloudProvider> = (ctx: ProviderPulumiCtx<I, S, P>) => Promise<O>;
+export type ProviderDeployFn<D, S, P extends CloudProvider = CloudProvider> = (ctx: ProviderDeployCtx<D, S, P>) => Promise<void>;
+export type ProviderAllocateFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderAllocateCtx<S, P>) => Promise<void>;
+export type ProviderDeallocateFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderDeallocateCtx<S, P>) => Promise<void>;
+export type ProviderUpsertArtifactsFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderUpsertArtifactsCtx<S, P>) => Promise<void>;
 declare const emptyStateSchema: z.ZodObject<{}, z.core.$strip>;
 export type EmptyStateShape = typeof emptyStateSchema.shape;
 export type InferredState<SShape extends z.ZodRawShape> = z.infer<z.ZodObject<SShape>>;
@@ -247,15 +289,15 @@ export type InferredState<SShape extends z.ZodRawShape> = z.infer<z.ZodObject<SS
 export type RuntimeState<SShape extends z.ZodRawShape> = {
 	[K in keyof InferredState<SShape>]: InferredState<SShape>[K] | PulumiOutput<InferredState<SShape>[K]>;
 };
-export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateShape, ConnectionType extends string = string, S = RuntimeState<SShape>> = {
+export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateShape, ConnectionType extends string = string, P extends CloudProvider = CloudProvider, S = RuntimeState<SShape>> = {
 	stateSchema?: z.ZodObject<SShape>;
 	initialState?: Partial<S>;
-	pulumi: ProviderPulumiFn<I, S, O>;
+	pulumi: ProviderPulumiFn<I, S, O, P>;
 	connect?: readonly ConnectionHandlerEntry<S, ConnectionType, any>[];
-	deploy?: ProviderDeployFn<D, S>;
-	allocateComponent?: ProviderAllocateFn<S>;
-	deallocateComponent?: ProviderDeallocateFn<S>;
-	upsertArtifacts?: ProviderUpsertArtifactsFn<S>;
+	deploy?: ProviderDeployFn<D, S, P>;
+	allocateComponent?: ProviderAllocateFn<S, P>;
+	deallocateComponent?: ProviderDeallocateFn<S, P>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<S, P>;
 };
 /**
  * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceDef type.
@@ -264,17 +306,17 @@ export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateSha
  */
 export type StoredConnectionHandlerEntry = {
 	interface: ConnectionInterfaceDef;
-	handler: (ctx: ConnectionHandlerCtx<any, any, any>) => Promise<ConnectionHandlerResult>;
+	handler: (ctx: ConnectionHandlerCtx<any, any, any, any>) => Promise<ConnectionHandlerResult>;
 };
 export type StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
 	initialState?: any;
-	pulumi: ProviderPulumiFn<any, any, any>;
+	pulumi: ProviderPulumiFn<any, any, any, any>;
 	connect?: readonly StoredConnectionHandlerEntry[];
-	deploy?: ProviderDeployFn<any, any>;
-	allocateComponent?: ProviderAllocateFn<any>;
-	deallocateComponent?: ProviderDeallocateFn<any>;
-	upsertArtifacts?: ProviderUpsertArtifactsFn<any>;
+	deploy?: ProviderDeployFn<any, any, any>;
+	allocateComponent?: ProviderAllocateFn<any, any>;
+	deallocateComponent?: ProviderDeallocateFn<any, any>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<any, any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
 /**
@@ -297,7 +339,7 @@ export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends
 	validationDeploymentInputSchema: z.ZodTypeAny;
 	private declaredConnectionInterfaces;
 	constructor(opts: InfraComponentOpts<CShape, DShape, OShape, ConnTypes>);
-	implement<SShape extends z.ZodRawShape = EmptyStateShape>(provider: CloudProvider, fns: ProviderFnsDef<InferZodType<CShape>, InferZodType<DShape>, InferOutputType<OShape>, SShape, keyof ConnTypes & string>): this;
+	implement<P extends CloudProvider, SShape extends z.ZodRawShape = EmptyStateShape>(provider: P, fns: ProviderFnsDef<InferZodType<CShape>, InferZodType<DShape>, InferOutputType<OShape>, SShape, keyof ConnTypes & string, P>): this;
 	/**
 	 * Get the schema for a specific connection interface.
 	 * Used by the orchestrator at runtime.

package/dist/index.js

@@ -1 +1,164 @@
-import{z as q}from"zod";import*as L from"@pulumi/pulumi";var Q;((H)=>{H.aws="aws";H.gcloud="gcloud";H.azure="azure";H.linode="linode";H.hetzner="hetzner";H.cloudflare="cloudflare"})(Q||={});var M;((E)=>{E.ipv4="ipv4";E.ipv6="ipv6";E.domain="domain"})(M||={});var V;((j)=>j.container_image="container_image")(V||={});var K=new Map;function W(b){return b.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[_\s]+/g,"-").toLowerCase().replace(/-+/g,"-").replace(/^-|-$/g,"")}function X(b){let j=W(b);if(j.length===0)throw new Error("Connection interface name cannot be empty");let B=K.get(j);if(B!==void 0&&B!==b)throw new Error(`Connection interface name collision: '${b}' resolves to '${j}' which is already registered by '${B}'`);return K.set(j,b),j}function Y(b,j){return{name:X(b),schema:j}}function k(b,j){return b.schema.merge(j)}var x=Y("tcp",q.object({url:q.object({type:q.nativeEnum(M),value:q.string()}),publicAccess:q.boolean()})),N=q.object({});function F(b){if(b instanceof q.ZodObject){let j=b.shape,B={};for(let E in j)B[E]=F(j[E]);return q.object(B)}if(b instanceof q.ZodOptional)return F(b.unwrap()).optional();if(b instanceof q.ZodNullable)return F(b.unwrap()).nullable();if(b instanceof q.ZodArray)return q.array(F(b.element));return q.union([b,q.custom((j)=>L.Output.isInstance(j))])}var Z=q.object({metadata:q.object({stateful:q.boolean(),proxiable:q.boolean()}),connectionTypes:q.record(q.string(),q.object({description:q.string().min(5)})),configSchema:q.custom(),deploymentInputSchema:q.custom(),outputSchema:q.custom()});function w(b){return b}var _=q.object({});class ${opts;providers;validationSchema;validationDeploymentInputSchema;declaredConnectionInterfaces=new Map;constructor(b){this.opts=Z.parse(b),this.providers={},this.validationSchema=F(b.configSchema),this.validationDeploymentInputSchema=F(b.deploymentInputSchema)}implement(b,j){return this.providers[b]={...j,stateSchema:j.stateSchema??_,initialState:j.initialState},this}getConnectionSchema(b){return b.schema}createDeclareConnectionInterfacesFn(){return(b)=>{for(let j of b){let B=j.interface.schema,E=F(B),J=E.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.name,{schema:E,data:j.data})}}}getDeclaredInterfaces(){return this.declaredConnectionInterfaces}}export{W as toCanonicalInterfaceName,k as extendSchema,Y as defineConnectionInterface,w as connectionHandler,M as TCPUrlType,x as TCPCI,$ as InfraComponent,V as DeploymentArtifactType,Q 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 ||= {});
+var connectionInterfaceRegistry = new Map;
+function toCanonicalInterfaceName(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase().replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function registerInterfaceName(name) {
+  const canonical = toCanonicalInterfaceName(name);
+  if (canonical.length === 0) {
+    throw new Error(`Connection interface name cannot be empty`);
+  }
+  const existing = connectionInterfaceRegistry.get(canonical);
+  if (existing !== undefined && existing !== name) {
+    throw new Error(`Connection interface name collision: '${name}' resolves to '${canonical}' which is already registered by '${existing}'`);
+  }
+  connectionInterfaceRegistry.set(canonical, name);
+  return canonical;
+}
+function defineConnectionInterface(name, schema) {
+  const canonicalName = registerInterfaceName(name);
+  return {
+    name: canonicalName,
+    schema
+  };
+}
+function extendSchema(parentDef, additionalSchema) {
+  return parentDef.schema.merge(additionalSchema);
+}
+var TCPCI = defineConnectionInterface("tcp", 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.ZodDefault) {
+    return transformSchemaToAcceptOutputs(schema._def.innerType).default(schema._def.defaultValue);
+  }
+  if (schema instanceof z.ZodArray) {
+    return z.array(transformSchemaToAcceptOutputs(schema.element));
+  }
+  if (schema instanceof z.ZodDiscriminatedUnion) {
+    const transformedOptions = schema._def.options.map((option) => transformSchemaToAcceptOutputs(option));
+    return z.discriminatedUnion(schema._def.discriminator, transformedOptions);
+  }
+  if (schema instanceof z.ZodRecord) {
+    const keyType = schema._def.keyType;
+    const valueType = schema._def.valueType;
+    const transformedKey = keyType ? transformSchemaToAcceptOutputs(keyType) : z.string();
+    const transformedValue = valueType ? transformSchemaToAcceptOutputs(valueType) : z.any();
+    return z.record(transformedKey, transformedValue);
+  }
+  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(interfaceDef) {
+    return interfaceDef.schema;
+  }
+  createDeclareConnectionInterfacesFn() {
+    return (entries) => {
+      for (const entry of entries) {
+        const schema = entry.interface.schema;
+        const transformedSchema = transformSchemaToAcceptOutputs(schema);
+        const parseResult = transformedSchema.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.name, {
+          schema: transformedSchema,
+          data: entry.data
+        });
+      }
+    };
+  }
+  getDeclaredInterfaces() {
+    return this.declaredConnectionInterfaces;
+  }
+}
+export {
+  toCanonicalInterfaceName,
+  extendSchema,
+  defineConnectionInterface,
+  connectionHandler,
+  TCPUrlType,
+  TCPCI,
+  InfraComponent,
+  DeploymentArtifactType,
+  CloudProvider
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdlcworks/components",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "module": "dist/index.js",
   "files": [
     "dist"
@@ -31,6 +31,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "@sdlc/types": "workspace:*",
     "zod": "4.1.13"
   }
 }