@sdlcworks/components 0.0.33 → 0.0.35

package/dist/index.d.ts

@@ -20,7 +20,8 @@ export declare enum CloudProvider {
 	cloudflare = "cloudflare"
 }
 export declare enum DeploymentArtifactType {
-	oci_spec_image = "oci_spec_image"
+	oci_spec_image = "oci_spec_image",
+	file = "file"
 }
 /**
  * GCP credential fields required for authentication.
@@ -44,6 +45,14 @@ export type BranchMetadataCloudCredentialCloudflare = {
 	CLOUDFLARE_API_TOKEN: string;
 	CLOUDFLARE_ACCOUNT_ID?: string;
 };
+/**
+ * Environment variable store for app components.
+ * Maps component name to its resolved environment variables (key-value pairs).
+ *
+ * For each infra component, this contains only the env vars for app components
+ * that are actively targeting that infra component.
+ */
+export type EnvStore = Record<string, Record<string, string>>;
 /**
  * Maps each CloudProvider to its corresponding credential type.
  * Used to provide fully-typed credentials in handler contexts.
@@ -61,11 +70,6 @@ export type ProviderCredentialsMap = {
  * Returns the typed credentials for the specified provider.
  */
 export type GetCredentialsFn<P extends CloudProvider> = () => ProviderCredentialsMap[P];
-export declare enum TCPUrlType {
-	ipv4 = "ipv4",
-	ipv6 = "ipv6",
-	domain = "domain"
-}
 /**
  * Transforms any interface name to canonical hyphen-separated lowercase form.
  *
@@ -128,16 +132,10 @@ export declare function extendSchema<TParentSchema extends z.ZodObject<z.ZodRawS
 	[k in keyof T]: T[k];
 } : never, TChildSchema["_zod"]["config"]>;
 /**
- * TCP Connection Interface - defines a TCP-based connection endpoint.
- * Use this for components that expose TCP services.
+ * Public HTTP Connection Interface - defines a public HTTP endpoint.
+ * No metadata, only URI is provided.
  */
-export declare const TCPCI: ConnectionInterfaceDef<"tcp", z.ZodObject<{
-	url: z.ZodObject<{
-		type: z.ZodEnum<typeof TCPUrlType>;
-		value: z.ZodString;
-	}, z.core.$strip>;
-	publicAccess: z.ZodBoolean;
-}, z.core.$strip>, undefined>;
+export declare const PublicHTTPCI: ConnectionInterfaceDef<"public-http", z.ZodObject<{}, z.core.$strip>, undefined>;
 /**
  * Extract the inferred data type from a ConnectionInterfaceDef.
  */
@@ -233,6 +231,7 @@ export type ProviderPulumiCtx<I, S, P extends CloudProvider = CloudProvider> = {
 	state: S;
 	declareConnectionInterfaces: DeclareConnectionInterfacesFn;
 	buildArtifacts: Record<string, ArtifactInfo>;
+	envStore: EnvStore;
 	getCredentials: GetCredentialsFn<P>;
 };
 /**
@@ -289,6 +288,7 @@ export type ProviderAllocateCtx<S, P extends CloudProvider = CloudProvider> = {
 		(name: string, ...values: any[]): string;
 		(strings: TemplateStringsArray, ...values: any[]): string;
 	};
+	envStore: EnvStore;
 	getCredentials: GetCredentialsFn<P>;
 };
 export type ProviderDeallocateCtx<S, P extends CloudProvider = CloudProvider> = {
@@ -304,6 +304,7 @@ export type ProviderDeallocateCtx<S, P extends CloudProvider = CloudProvider> =
 export type ProviderUpsertArtifactsCtx<S, P extends CloudProvider = CloudProvider> = {
 	buildArtifacts: Record<string, ArtifactInfo>;
 	state: S;
+	envStore: EnvStore;
 	getCredentials: GetCredentialsFn<P>;
 };
 export type ProviderPulumiFn<I, S, O, P extends CloudProvider = CloudProvider> = (ctx: ProviderPulumiCtx<I, S, P>) => Promise<O>;

package/dist/index.js

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

package/package.json

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