@sdlcworks/components 0.0.17 → 0.0.18

package/dist/index.d.ts

@@ -149,23 +149,13 @@ export type ConnectionHandlerEntry<S, ConnectionType extends string, C extends C
 	interface: C;
 	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<C>, ConnectionType>) => Promise<ConnectionHandlerResult>;
 };
-/**
- * Helper function that preserves type inference for connection handler entries.
- * Use this to get proper typing for ctx.connectionData in handlers.
- *
- * @example
- * connect: [
- *   connectionHandler({
- *     interface: ServiceAccountCI,
- *     handler: async (ctx) => {
- *       // ctx.connectionData is now properly typed from ServiceAccountCI schema
- *       ctx.connectionData.email // string
- *       return {};
- *     },
- *   }),
- * ] as const,
- */
-export declare function connectionHandler<S, ConnectionType extends string, C extends ConnectionInterfaceClass>(entry: ConnectionHandlerEntry<S, ConnectionType, C>): ConnectionHandlerEntry<S, ConnectionType, C>;
+export declare function connectionHandler<C extends ConnectionInterfaceClass>(entry: {
+	interface: C;
+	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<C>, any>) => Promise<ConnectionHandlerResult>;
+}): {
+	interface: C;
+	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<C>, any>) => Promise<ConnectionHandlerResult>;
+};
 export type ProviderDeployCtx<D, S> = {
 	state: S;
 } & Record<string, DeploymentInfo>;
@@ -176,7 +166,7 @@ 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?: readonly ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType, ConnectionInterfaceClass>[];
+	connect?: readonly ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType, any>[];
 	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
 };
 /**

package/dist/index.js

@@ -1 +1,113 @@
-import{z as b}from"zod";import*as H from"@pulumi/pulumi";var K;((j)=>{j.aws="aws";j.gcloud="gcloud";j.azure="azure";j.linode="linode";j.hetzner="hetzner";j.cloudflare="cloudflare"})(K||={});var L;((g)=>g.container_image="container_image")(L||={});class J{}function V(x){return class extends J{schema=x}}var W=b.object({});function q(x){if(x instanceof b.ZodObject){let g=x.shape,B={};for(let E in g)B[E]=q(g[E]);return b.object(B)}if(x instanceof b.ZodOptional)return q(x.unwrap()).optional();if(x instanceof b.ZodNullable)return q(x.unwrap()).nullable();if(x instanceof b.ZodArray)return b.array(q(x.element));return b.union([x,b.custom((g)=>H.Output.isInstance(g))])}var M=b.object({metadata:b.object({stateful:b.boolean(),proxiable:b.boolean()}),connectionTypes:b.record(b.string(),b.object({description:b.string().min(5)})),configSchema:b.custom(),deploymentInputSchema:b.custom(),outputSchema:b.custom()});function X(x){return x}var N=b.object({});class Q{opts;providers;validationSchema;validationDeploymentInputSchema;declaredConnectionInterfaces=new Map;constructor(x){this.opts=M.parse(x),this.providers={},this.validationSchema=q(x.configSchema),this.validationDeploymentInputSchema=q(x.deploymentInputSchema)}implement(x,g){return this.providers[x]={...g,stateSchema:g.stateSchema??N},this}getConnectionSchema(x){return new x().schema}createDeclareConnectionInterfacesFn(){return(x)=>{for(let g of x){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.declaredConnectionInterfaces.set(g.interface,g.data)}}}getDeclaredInterfaces(){return this.declaredConnectionInterfaces}}export{V as createConnectionInterface,X as connectionHandler,Q as InfraComponent,L as DeploymentArtifactType,J as ConnectionInterface,K 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 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()
+});
+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
+    };
+    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,
+  connectionHandler,
+  InfraComponent,
+  DeploymentArtifactType,
+  ConnectionInterface,
+  CloudProvider
+};

package/package.json

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