@sdlcworks/components 0.0.18 → 0.0.20

package/dist/index.d.ts

@@ -11,6 +11,11 @@ export declare enum CloudProvider {
 	hetzner = "hetzner",
 	cloudflare = "cloudflare"
 }
+export declare enum TCPUrlType {
+	ipv4 = "ipv4",
+	ipv6 = "ipv6",
+	domain = "domain"
+}
 export declare enum DeploymentArtifactType {
 	container_image = "container_image"
 }
@@ -36,6 +41,50 @@ export declare function createConnectionInterface<TSchema extends z.ZodObject<z.
 		readonly schema: TSchema;
 	};
 };
+/**
+ * Extends a ConnectionInterface class with additional schema fields.
+ * The resulting class merges the parent and child schemas.
+ *
+ * @example
+ * const BaseCI = createConnectionInterface(
+ *   z.object({ foo: z.string() })
+ * );
+ * const ExtendedCI = extendConnectionInterface(
+ *   BaseCI,
+ *   z.object({ bar: z.number() })
+ * );
+ * // ExtendedCI schema: { foo: string, bar: number }
+ */
+export declare function extendConnectionInterface<TParentSchema extends z.ZodObject<z.ZodRawShape>, TChildSchema extends z.ZodObject<z.ZodRawShape>>(parentClass: ConnectionInterfaceClass<TParentSchema>, additionalSchema: TChildSchema): {
+	new (): {
+		readonly schema: z.ZodObject<((string | number) & keyof TChildSchema["shape"] extends never ? Readonly<{
+			[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+		}> & TChildSchema["shape"] : (Readonly<{
+			[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+		}> extends infer T_1 extends z.core.util.SomeObject ? {
+			[K in keyof T_1 as K extends keyof TChildSchema["shape"] ? never : K]: T_1[K];
+		} : never) & (TChildSchema["shape"] extends infer T_2 extends z.core.util.SomeObject ? {
+			[K_1 in keyof T_2]: T_2[K_1];
+		} : never)) extends infer T ? {
+			[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.
+ */
+export declare const TCPCI: {
+	new (): {
+		readonly schema: z.ZodObject<{
+			url: z.ZodObject<{
+				type: z.ZodEnum<typeof TCPUrlType>;
+				value: z.ZodString;
+			}, z.core.$strip>;
+			publicAccess: z.ZodBoolean;
+		}, z.core.$strip>;
+	};
+};
 /**
  * Type alias for ConnectionInterface class constructors.
  */
@@ -107,6 +156,12 @@ export type InfraComponentOpts<CShape extends z.ZodRawShape, DShape extends z.Zo
 	connectionTypes: ConnTypes;
 };
 export type InfraComponentInputs<C> = C;
+export type ArtifactInfo = {
+	artifact: {
+		uri: string;
+		type: DeploymentArtifactType;
+	};
+};
 export type DeploymentInfo = {
 	config: Record<string, any>;
 	artifact: {
@@ -123,7 +178,7 @@ export type ProviderPulumiCtx<I, S> = {
 	inputs: I;
 	state: S;
 	declareConnectionInterfaces: DeclareConnectionInterfacesFn;
-	buildArtifacts: Record<string, DeploymentInfo>;
+	buildArtifacts: Record<string, ArtifactInfo>;
 };
 /**
  * Context passed to connection handlers.
@@ -137,11 +192,9 @@ export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string
 };
 /**
  * Result returned by connection handlers.
- * Handlers can optionally return a URI for the connection.
+ * Maps component names to their URIs, or void if no URIs need to be returned.
  */
-export type ConnectionHandlerResult = {
-	uri?: PulumiOutput<string>;
-};
+export type ConnectionHandlerResult = Record<string, PulumiOutput<string>> | void;
 /**
  * A connection handler entry mapping a ConnectionInterface to its handler function.
  */
@@ -159,15 +212,44 @@ export declare function connectionHandler<C extends ConnectionInterfaceClass>(en
 export type ProviderDeployCtx<D, S> = {
 	state: S;
 } & Record<string, DeploymentInfo>;
+export type ProviderAllocateCtx<S> = {
+	name: string;
+	deploymentConfig: Record<string, any>;
+	state: S;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
+};
+export type ProviderDeallocateCtx<S> = {
+	name: string;
+	deploymentConfig: Record<string, any>;
+	state: S;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
+};
+export type ProviderUpsertArtifactsCtx<S> = {
+	buildArtifacts: Record<string, ArtifactInfo>;
+	state: S;
+};
 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>;
 declare const emptyStateSchema: z.ZodObject<{}, z.core.$strip>;
 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>;
+	initialState?: z.infer<z.ZodObject<SShape>>;
 	pulumi: ProviderPulumiFn<I, z.infer<z.ZodObject<SShape>>, O>;
 	connect?: readonly ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType, any>[];
 	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
+	allocateComponent?: ProviderAllocateFn<z.infer<z.ZodObject<SShape>>>;
+	deallocateComponent?: ProviderDeallocateFn<z.infer<z.ZodObject<SShape>>>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<z.infer<z.ZodObject<SShape>>>;
 };
 /**
  * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceClass type.
@@ -180,9 +262,13 @@ export type StoredConnectionHandlerEntry = {
 };
 export type StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
+	initialState?: any;
 	pulumi: ProviderPulumiFn<any, any, any>;
 	connect?: readonly StoredConnectionHandlerEntry[];
 	deploy?: ProviderDeployFn<any, any>;
+	allocateComponent?: ProviderAllocateFn<any>;
+	deallocateComponent?: ProviderDeallocateFn<any>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
 export type DeclaredConnectionInterfaces = Map<ConnectionInterfaceClass, any>;

package/dist/index.js

@@ -10,6 +10,12 @@ var CloudProvider;
   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";
@@ -22,6 +28,20 @@ function createConnectionInterface(schema) {
     schema = schema;
   };
 }
+function extendConnectionInterface(parentClass, additionalSchema) {
+  const parentInstance = new parentClass;
+  const mergedSchema = parentInstance.schema.merge(additionalSchema);
+  return class extends ConnectionInterface {
+    schema = mergedSchema;
+  };
+}
+var TCPCI = createConnectionInterface(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) {
@@ -78,7 +98,8 @@ class InfraComponent {
   implement(provider, fns) {
     this.providers[provider] = {
       ...fns,
-      stateSchema: fns.stateSchema ?? emptyStateSchema
+      stateSchema: fns.stateSchema ?? emptyStateSchema,
+      initialState: fns.initialState
     };
     return this;
   }
@@ -104,8 +125,11 @@ class InfraComponent {
   }
 }
 export {
+  extendConnectionInterface,
   createConnectionInterface,
   connectionHandler,
+  TCPUrlType,
+  TCPCI,
   InfraComponent,
   DeploymentArtifactType,
   ConnectionInterface,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdlcworks/components",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "module": "dist/index.js",
   "files": [
     "dist"
@@ -31,6 +31,6 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "zod": "^4.1.13"
+    "zod": "4.1.13"
   }
 }