@geekmidas/constructs 0.0.1

package/dist/AmazonApiGatewayV2EndpointAdaptor-YlFoFSS9.cjs

@@ -0,0 +1,46 @@
+const require_AmazonApiGatewayEndpointAdaptor = require('./AmazonApiGatewayEndpointAdaptor-i74DEUbc.cjs');
+const require_parseQueryParams = require('./parseQueryParams-BzPop4I1.cjs');
+
+//#region src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts
+var AmazonApiGatewayV2Endpoint = class extends require_AmazonApiGatewayEndpointAdaptor.AmazonApiGatewayEndpoint {
+	getInput(e) {
+		const queryParams = e.queryStringParameters || {};
+		const processedParams = {};
+		for (const [key, value] of Object.entries(queryParams)) if (value !== void 0) if (value.includes(",") && !value.includes("\"")) processedParams[key] = value.split(",").map((v) => v.trim());
+		else processedParams[key] = value;
+		return {
+			body: e.body ? JSON.parse(e.body) : void 0,
+			query: require_parseQueryParams.parseQueryParams(processedParams),
+			params: e.pathParameters || {}
+		};
+	}
+	getLoggerContext(event, context) {
+		return {
+			fn: {
+				name: context.functionName,
+				version: context.functionVersion
+			},
+			req: {
+				id: event.requestContext.requestId,
+				awsRequestId: context.awsRequestId,
+				ip: event.requestContext.http.sourceIp,
+				userAgent: event.requestContext.http.userAgent || void 0,
+				path: event.requestContext.http.path
+			}
+		};
+	}
+	constructor(envParser, endpoint) {
+		super(envParser, endpoint);
+		this.envParser = envParser;
+		this.endpoint = endpoint;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'AmazonApiGatewayV2Endpoint', {
+  enumerable: true,
+  get: function () {
+    return AmazonApiGatewayV2Endpoint;
+  }
+});
+//# sourceMappingURL=AmazonApiGatewayV2EndpointAdaptor-YlFoFSS9.cjs.map

package/dist/AmazonApiGatewayV2EndpointAdaptor-YlFoFSS9.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmazonApiGatewayV2EndpointAdaptor-YlFoFSS9.cjs","names":["AmazonApiGatewayEndpoint","e: APIGatewayProxyEventV2","processedParams: Record<string, string | string[]>","event: APIGatewayProxyEventV2","context: Context","envParser: EnvironmentParser<{}>","endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher\n    >"],"sources":["../src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { HttpMethod } from '../types';\nimport type { Endpoint, EndpointSchemas } from './Endpoint';\n\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { Service } from '@geekmidas/services';\nimport type { APIGatewayProxyEventV2, Context } from 'aws-lambda';\nimport {\n  AmazonApiGatewayEndpoint,\n  type AmazonApiGatewayV2EndpointHandler,\n  type GetInputResponse,\n  type LoggerContext,\n} from './AmazonApiGatewayEndpointAdaptor';\nimport { parseQueryParams } from './parseQueryParams';\n\nexport class AmazonApiGatewayV2Endpoint<\n  TRoute extends string,\n  TMethod extends HttpMethod,\n  TInput extends EndpointSchemas = {},\n  TOutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n> extends AmazonApiGatewayEndpoint<\n  AmazonApiGatewayV2EndpointHandler,\n  APIGatewayProxyEventV2,\n  TRoute,\n  TMethod,\n  TInput,\n  TOutSchema,\n  TServices,\n  TLogger,\n  TSession,\n  TEventPublisher\n> {\n  getInput(e: APIGatewayProxyEventV2): GetInputResponse {\n    // API Gateway V2 handles arrays as comma-separated values\n    const queryParams = e.queryStringParameters || {};\n    const processedParams: Record<string, string | string[]> = {};\n\n    for (const [key, value] of Object.entries(queryParams)) {\n      if (value !== undefined) {\n        // Check if value contains comma and could be an array\n        // Be careful not to split values that legitimately contain commas\n        if (value.includes(',') && !value.includes('\"')) {\n          processedParams[key] = value.split(',').map((v) => v.trim());\n        } else {\n          processedParams[key] = value;\n        }\n      }\n    }\n\n    return {\n      body: e.body ? JSON.parse(e.body) : undefined,\n      query: parseQueryParams(processedParams),\n      params: e.pathParameters || {},\n    };\n  }\n  getLoggerContext(\n    event: APIGatewayProxyEventV2,\n    context: Context,\n  ): LoggerContext {\n    return {\n      fn: {\n        name: context.functionName,\n        version: context.functionVersion,\n      },\n      req: {\n        id: event.requestContext.requestId,\n        awsRequestId: context.awsRequestId,\n        ip: event.requestContext.http.sourceIp,\n        userAgent: event.requestContext.http.userAgent || undefined,\n        path: event.requestContext.http.path,\n      },\n    };\n  }\n  constructor(\n    protected envParser: EnvironmentParser<{}>,\n    protected readonly endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher\n    >,\n  ) {\n    super(envParser, endpoint);\n  }\n}\n"],"mappings":";;;;AAiBA,IAAa,6BAAb,cASUA,iEAWR;CACA,SAASC,GAA6C;EAEpD,MAAM,cAAc,EAAE,yBAAyB,CAAE;EACjD,MAAMC,kBAAqD,CAAE;AAE7D,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,YAAY,CACpD,KAAI,iBAGF,KAAI,MAAM,SAAS,IAAI,KAAK,MAAM,SAAS,KAAI,CAC7C,iBAAgB,OAAO,MAAM,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;MAE5D,iBAAgB,OAAO;AAK7B,SAAO;GACL,MAAM,EAAE,OAAO,KAAK,MAAM,EAAE,KAAK;GACjC,OAAO,0CAAiB,gBAAgB;GACxC,QAAQ,EAAE,kBAAkB,CAAE;EAC/B;CACF;CACD,iBACEC,OACAC,SACe;AACf,SAAO;GACL,IAAI;IACF,MAAM,QAAQ;IACd,SAAS,QAAQ;GAClB;GACD,KAAK;IACH,IAAI,MAAM,eAAe;IACzB,cAAc,QAAQ;IACtB,IAAI,MAAM,eAAe,KAAK;IAC9B,WAAW,MAAM,eAAe,KAAK;IACrC,MAAM,MAAM,eAAe,KAAK;GACjC;EACF;CACF;CACD,YACYC,WACSC,UAUnB;AACA,QAAM,WAAW,SAAS;EAZhB;EACS;CAYpB;AACF"}

package/dist/AmazonApiGatewayV2EndpointAdaptor-zfd1gqXA.d.mts

@@ -0,0 +1,21 @@
+import { HttpMethod } from "./types-DBKNYvsW.mjs";
+import { Endpoint, EndpointSchemas } from "./Endpoint-DCn53Vd8.mjs";
+import { AmazonApiGatewayEndpoint, AmazonApiGatewayV2EndpointHandler, GetInputResponse, LoggerContext } from "./AmazonApiGatewayEndpointAdaptor-BoBh7vvD.mjs";
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { Service } from "@geekmidas/services";
+import { EventPublisher } from "@geekmidas/events";
+import { Logger } from "@geekmidas/logger";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { APIGatewayProxyEventV2, Context } from "aws-lambda";
+
+//#region src/endpoints/AmazonApiGatewayV2EndpointAdaptor.d.ts
+declare class AmazonApiGatewayV2Endpoint<TRoute extends string, TMethod extends HttpMethod, TInput extends EndpointSchemas = {}, TOutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown, TEventPublisher extends EventPublisher<any> | undefined = undefined> extends AmazonApiGatewayEndpoint<AmazonApiGatewayV2EndpointHandler, APIGatewayProxyEventV2, TRoute, TMethod, TInput, TOutSchema, TServices, TLogger, TSession, TEventPublisher> {
+  protected envParser: EnvironmentParser<{}>;
+  protected readonly endpoint: Endpoint<TRoute, TMethod, TInput, TOutSchema, TServices, TLogger, TSession, TEventPublisher>;
+  getInput(e: APIGatewayProxyEventV2): GetInputResponse;
+  getLoggerContext(event: APIGatewayProxyEventV2, context: Context): LoggerContext;
+  constructor(envParser: EnvironmentParser<{}>, endpoint: Endpoint<TRoute, TMethod, TInput, TOutSchema, TServices, TLogger, TSession, TEventPublisher>);
+}
+//#endregion
+export { AmazonApiGatewayV2Endpoint };
+//# sourceMappingURL=AmazonApiGatewayV2EndpointAdaptor-zfd1gqXA.d.mts.map

package/dist/BaseFunctionBuilder-5QCHkchp.d.cts

@@ -0,0 +1,31 @@
+import { ConstructType } from "./Construct-Bm-PSO2V.cjs";
+import { EventPublisher, MappedEvent } from "@geekmidas/events";
+import { Logger } from "@geekmidas/logger";
+import { Service } from "@geekmidas/services";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { ComposableStandardSchema, InferComposableStandardSchema } from "@geekmidas/schema";
+
+//#region src/functions/BaseFunctionBuilder.d.ts
+declare abstract class BaseFunctionBuilder<TInput extends ComposableStandardSchema, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, TEventPublisher extends EventPublisher<any> | undefined = undefined, TEventPublisherServiceName extends string = string> {
+  type: ConstructType;
+  protected inputSchema?: TInput;
+  protected outputSchema?: OutSchema;
+  protected _timeout?: number;
+  _services: TServices;
+  _logger: TLogger;
+  protected _events: MappedEvent<TEventPublisher, OutSchema>[];
+  protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
+  static isStandardSchemaV1(s: unknown): s is StandardSchemaV1;
+  static parseComposableStandardSchema<T extends ComposableStandardSchema | undefined>(data: unknown, schema: T): Promise<InferComposableStandardSchema<T>>;
+  constructor(type?: ConstructType);
+  abstract services<T extends Service[]>(services: T): any;
+  abstract logger<T extends Logger>(logger: T): any;
+  timeout(timeout: number): this;
+  abstract output<T extends StandardSchemaV1>(schema: T): any;
+  abstract input<T extends ComposableStandardSchema>(schema: T): any;
+  event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(event: TEvent): this;
+  publisher<T extends EventPublisher<any>, TName extends string>(publisher: Service<TName, T>): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName>;
+}
+//#endregion
+export { BaseFunctionBuilder };
+//# sourceMappingURL=BaseFunctionBuilder-5QCHkchp.d.cts.map

package/dist/BaseFunctionBuilder-BFPVGnKi.d.mts

@@ -0,0 +1,31 @@
+import { ConstructType } from "./Construct-DIguIyw4.mjs";
+import { Service } from "@geekmidas/services";
+import { EventPublisher, MappedEvent } from "@geekmidas/events";
+import { Logger } from "@geekmidas/logger";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { ComposableStandardSchema, InferComposableStandardSchema } from "@geekmidas/schema";
+
+//#region src/functions/BaseFunctionBuilder.d.ts
+declare abstract class BaseFunctionBuilder<TInput extends ComposableStandardSchema, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, TEventPublisher extends EventPublisher<any> | undefined = undefined, TEventPublisherServiceName extends string = string> {
+  type: ConstructType;
+  protected inputSchema?: TInput;
+  protected outputSchema?: OutSchema;
+  protected _timeout?: number;
+  _services: TServices;
+  _logger: TLogger;
+  protected _events: MappedEvent<TEventPublisher, OutSchema>[];
+  protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
+  static isStandardSchemaV1(s: unknown): s is StandardSchemaV1;
+  static parseComposableStandardSchema<T extends ComposableStandardSchema | undefined>(data: unknown, schema: T): Promise<InferComposableStandardSchema<T>>;
+  constructor(type?: ConstructType);
+  abstract services<T extends Service[]>(services: T): any;
+  abstract logger<T extends Logger>(logger: T): any;
+  timeout(timeout: number): this;
+  abstract output<T extends StandardSchemaV1>(schema: T): any;
+  abstract input<T extends ComposableStandardSchema>(schema: T): any;
+  event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(event: TEvent): this;
+  publisher<T extends EventPublisher<any>, TName extends string>(publisher: Service<TName, T>): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName>;
+}
+//#endregion
+export { BaseFunctionBuilder };
+//# sourceMappingURL=BaseFunctionBuilder-BFPVGnKi.d.mts.map

package/dist/BaseFunctionBuilder-BPE9JBbT.mjs

@@ -0,0 +1,56 @@
+import { ConstructType } from "./Construct-BbKCIPQm.mjs";
+import { ConsoleLogger } from "@geekmidas/logger/console";
+import get from "lodash.get";
+
+//#region src/functions/BaseFunctionBuilder.ts
+const DEFAULT_LOGGER$1 = new ConsoleLogger();
+var BaseFunctionBuilder = class BaseFunctionBuilder {
+	inputSchema;
+	outputSchema;
+	_timeout;
+	_services = [];
+	_logger = DEFAULT_LOGGER$1;
+	_events = [];
+	_publisher;
+	static isStandardSchemaV1(s) {
+		const schema = s["~standard"];
+		return schema && typeof schema.validate === "function";
+	}
+	static async parseComposableStandardSchema(data, schema) {
+		if (BaseFunctionBuilder.isStandardSchemaV1(schema)) {
+			const validated = await schema["~standard"].validate(data);
+			if (validated.issues) throw validated.issues;
+			return validated.value;
+		}
+		const result = {};
+		for (const key in schema) {
+			const item = schema[key];
+			if (BaseFunctionBuilder.isStandardSchemaV1(item)) {
+				const value = get(data, key);
+				const validated = await item["~standard"].validate(value);
+				if (validated.issues) throw validated.issues;
+				result[key] = validated.value;
+			}
+		}
+		return result;
+	}
+	constructor(type = ConstructType.Function) {
+		this.type = type;
+	}
+	timeout(timeout) {
+		this._timeout = timeout;
+		return this;
+	}
+	event(event) {
+		this._events.push(event);
+		return this;
+	}
+	publisher(publisher) {
+		this._publisher = publisher;
+		return this;
+	}
+};
+
+//#endregion
+export { BaseFunctionBuilder };
+//# sourceMappingURL=BaseFunctionBuilder-BPE9JBbT.mjs.map

package/dist/BaseFunctionBuilder-BPE9JBbT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseFunctionBuilder-BPE9JBbT.mjs","names":["DEFAULT_LOGGER","s: unknown","data: unknown","schema: T","result: any","timeout: number","event: TEvent","publisher: Service<TName, T>"],"sources":["../src/functions/BaseFunctionBuilder.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport get from 'lodash.get';\nimport { ConstructType } from '../Construct';\n\nimport type { EventPublisher, MappedEvent } from '@geekmidas/events';\nimport type {\n  ComposableStandardSchema,\n  InferComposableStandardSchema,\n} from '@geekmidas/schema';\n\nconst DEFAULT_LOGGER = new ConsoleLogger() as any;\n\nexport abstract class BaseFunctionBuilder<\n  TInput extends ComposableStandardSchema,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> {\n  protected inputSchema?: TInput;\n  protected outputSchema?: OutSchema;\n  protected _timeout?: number;\n\n  public _services: TServices = [] as Service[] as TServices;\n  public _logger: TLogger = DEFAULT_LOGGER;\n\n  protected _events: MappedEvent<TEventPublisher, OutSchema>[] = [];\n  protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;\n\n  static isStandardSchemaV1(s: unknown): s is StandardSchemaV1 {\n    const schema = (s as StandardSchemaV1)['~standard'];\n\n    return schema && typeof schema.validate === 'function';\n  }\n\n  static async parseComposableStandardSchema<\n    T extends ComposableStandardSchema | undefined,\n  >(data: unknown, schema: T): Promise<InferComposableStandardSchema<T>> {\n    if (BaseFunctionBuilder.isStandardSchemaV1(schema)) {\n      const validated = await schema['~standard'].validate(data);\n\n      if (validated.issues) {\n        throw validated.issues;\n      }\n\n      return validated.value as InferComposableStandardSchema<T>;\n    }\n\n    const result: any = {};\n    for (const key in schema) {\n      const item = schema[key];\n      if (BaseFunctionBuilder.isStandardSchemaV1(item)) {\n        const value = get(data, key);\n        const validated = await item['~standard'].validate(value);\n\n        if (validated.issues) {\n          throw validated.issues;\n        }\n\n        result[key] = validated.value;\n      }\n    }\n\n    return result as InferComposableStandardSchema<T>;\n  }\n\n  constructor(public type = ConstructType.Function) {}\n\n  abstract services<T extends Service[]>(services: T): any;\n\n  abstract logger<T extends Logger>(logger: T): any;\n\n  timeout(timeout: number): this {\n    this._timeout = timeout;\n    return this;\n  }\n\n  abstract output<T extends StandardSchemaV1>(schema: T): any;\n\n  abstract input<T extends ComposableStandardSchema>(schema: T): any;\n\n  event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(\n    event: TEvent,\n  ): this {\n    this._events.push(event);\n    return this;\n  }\n\n  publisher<T extends EventPublisher<any>, TName extends string>(\n    publisher: Service<TName, T>,\n  ): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName> {\n    this._publisher = publisher as unknown as Service<\n      TEventPublisherServiceName,\n      TEventPublisher\n    >;\n\n    return this as unknown as BaseFunctionBuilder<\n      TInput,\n      OutSchema,\n      TServices,\n      TLogger,\n      T,\n      TName\n    >;\n  }\n}\n"],"mappings":";;;;;AAaA,MAAMA,mBAAiB,IAAI;AAE3B,IAAsB,sBAAtB,MAAsB,oBAOpB;CACA,AAAU;CACV,AAAU;CACV,AAAU;CAEV,AAAO,YAAuB,CAAE;CAChC,AAAO,UAAmBA;CAE1B,AAAU,UAAqD,CAAE;CACjE,AAAU;CAEV,OAAO,mBAAmBC,GAAmC;EAC3D,MAAM,SAAU,EAAuB;AAEvC,SAAO,iBAAiB,OAAO,aAAa;CAC7C;CAED,aAAa,8BAEXC,MAAeC,QAAsD;AACrE,MAAI,oBAAoB,mBAAmB,OAAO,EAAE;GAClD,MAAM,YAAY,MAAM,OAAO,aAAa,SAAS,KAAK;AAE1D,OAAI,UAAU,OACZ,OAAM,UAAU;AAGlB,UAAO,UAAU;EAClB;EAED,MAAMC,SAAc,CAAE;AACtB,OAAK,MAAM,OAAO,QAAQ;GACxB,MAAM,OAAO,OAAO;AACpB,OAAI,oBAAoB,mBAAmB,KAAK,EAAE;IAChD,MAAM,QAAQ,IAAI,MAAM,IAAI;IAC5B,MAAM,YAAY,MAAM,KAAK,aAAa,SAAS,MAAM;AAEzD,QAAI,UAAU,OACZ,OAAM,UAAU;AAGlB,WAAO,OAAO,UAAU;GACzB;EACF;AAED,SAAO;CACR;CAED,YAAmB,OAAO,cAAc,UAAU;EAA/B;CAAiC;CAMpD,QAAQC,SAAuB;AAC7B,OAAK,WAAW;AAChB,SAAO;CACR;CAMD,MACEC,OACM;AACN,OAAK,QAAQ,KAAK,MAAM;AACxB,SAAO;CACR;CAED,UACEC,WACsE;AACtE,OAAK,aAAa;AAKlB,SAAO;CAQR;AACF"}

package/dist/BaseFunctionBuilder-DtO4Nwxm.cjs

@@ -0,0 +1,62 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_Construct = require('./Construct-BSEs6uwW.cjs');
+const __geekmidas_logger_console = require_chunk.__toESM(require("@geekmidas/logger/console"));
+const lodash_get = require_chunk.__toESM(require("lodash.get"));
+
+//#region src/functions/BaseFunctionBuilder.ts
+const DEFAULT_LOGGER = new __geekmidas_logger_console.ConsoleLogger();
+var BaseFunctionBuilder = class BaseFunctionBuilder {
+	inputSchema;
+	outputSchema;
+	_timeout;
+	_services = [];
+	_logger = DEFAULT_LOGGER;
+	_events = [];
+	_publisher;
+	static isStandardSchemaV1(s) {
+		const schema = s["~standard"];
+		return schema && typeof schema.validate === "function";
+	}
+	static async parseComposableStandardSchema(data, schema) {
+		if (BaseFunctionBuilder.isStandardSchemaV1(schema)) {
+			const validated = await schema["~standard"].validate(data);
+			if (validated.issues) throw validated.issues;
+			return validated.value;
+		}
+		const result = {};
+		for (const key in schema) {
+			const item = schema[key];
+			if (BaseFunctionBuilder.isStandardSchemaV1(item)) {
+				const value = (0, lodash_get.default)(data, key);
+				const validated = await item["~standard"].validate(value);
+				if (validated.issues) throw validated.issues;
+				result[key] = validated.value;
+			}
+		}
+		return result;
+	}
+	constructor(type = require_Construct.ConstructType.Function) {
+		this.type = type;
+	}
+	timeout(timeout) {
+		this._timeout = timeout;
+		return this;
+	}
+	event(event) {
+		this._events.push(event);
+		return this;
+	}
+	publisher(publisher) {
+		this._publisher = publisher;
+		return this;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'BaseFunctionBuilder', {
+  enumerable: true,
+  get: function () {
+    return BaseFunctionBuilder;
+  }
+});
+//# sourceMappingURL=BaseFunctionBuilder-DtO4Nwxm.cjs.map

package/dist/BaseFunctionBuilder-DtO4Nwxm.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseFunctionBuilder-DtO4Nwxm.cjs","names":["ConsoleLogger","s: unknown","data: unknown","schema: T","result: any","ConstructType","timeout: number","event: TEvent","publisher: Service<TName, T>"],"sources":["../src/functions/BaseFunctionBuilder.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport get from 'lodash.get';\nimport { ConstructType } from '../Construct';\n\nimport type { EventPublisher, MappedEvent } from '@geekmidas/events';\nimport type {\n  ComposableStandardSchema,\n  InferComposableStandardSchema,\n} from '@geekmidas/schema';\n\nconst DEFAULT_LOGGER = new ConsoleLogger() as any;\n\nexport abstract class BaseFunctionBuilder<\n  TInput extends ComposableStandardSchema,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> {\n  protected inputSchema?: TInput;\n  protected outputSchema?: OutSchema;\n  protected _timeout?: number;\n\n  public _services: TServices = [] as Service[] as TServices;\n  public _logger: TLogger = DEFAULT_LOGGER;\n\n  protected _events: MappedEvent<TEventPublisher, OutSchema>[] = [];\n  protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;\n\n  static isStandardSchemaV1(s: unknown): s is StandardSchemaV1 {\n    const schema = (s as StandardSchemaV1)['~standard'];\n\n    return schema && typeof schema.validate === 'function';\n  }\n\n  static async parseComposableStandardSchema<\n    T extends ComposableStandardSchema | undefined,\n  >(data: unknown, schema: T): Promise<InferComposableStandardSchema<T>> {\n    if (BaseFunctionBuilder.isStandardSchemaV1(schema)) {\n      const validated = await schema['~standard'].validate(data);\n\n      if (validated.issues) {\n        throw validated.issues;\n      }\n\n      return validated.value as InferComposableStandardSchema<T>;\n    }\n\n    const result: any = {};\n    for (const key in schema) {\n      const item = schema[key];\n      if (BaseFunctionBuilder.isStandardSchemaV1(item)) {\n        const value = get(data, key);\n        const validated = await item['~standard'].validate(value);\n\n        if (validated.issues) {\n          throw validated.issues;\n        }\n\n        result[key] = validated.value;\n      }\n    }\n\n    return result as InferComposableStandardSchema<T>;\n  }\n\n  constructor(public type = ConstructType.Function) {}\n\n  abstract services<T extends Service[]>(services: T): any;\n\n  abstract logger<T extends Logger>(logger: T): any;\n\n  timeout(timeout: number): this {\n    this._timeout = timeout;\n    return this;\n  }\n\n  abstract output<T extends StandardSchemaV1>(schema: T): any;\n\n  abstract input<T extends ComposableStandardSchema>(schema: T): any;\n\n  event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(\n    event: TEvent,\n  ): this {\n    this._events.push(event);\n    return this;\n  }\n\n  publisher<T extends EventPublisher<any>, TName extends string>(\n    publisher: Service<TName, T>,\n  ): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName> {\n    this._publisher = publisher as unknown as Service<\n      TEventPublisherServiceName,\n      TEventPublisher\n    >;\n\n    return this as unknown as BaseFunctionBuilder<\n      TInput,\n      OutSchema,\n      TServices,\n      TLogger,\n      T,\n      TName\n    >;\n  }\n}\n"],"mappings":";;;;;;AAaA,MAAM,iBAAiB,IAAIA;AAE3B,IAAsB,sBAAtB,MAAsB,oBAOpB;CACA,AAAU;CACV,AAAU;CACV,AAAU;CAEV,AAAO,YAAuB,CAAE;CAChC,AAAO,UAAmB;CAE1B,AAAU,UAAqD,CAAE;CACjE,AAAU;CAEV,OAAO,mBAAmBC,GAAmC;EAC3D,MAAM,SAAU,EAAuB;AAEvC,SAAO,iBAAiB,OAAO,aAAa;CAC7C;CAED,aAAa,8BAEXC,MAAeC,QAAsD;AACrE,MAAI,oBAAoB,mBAAmB,OAAO,EAAE;GAClD,MAAM,YAAY,MAAM,OAAO,aAAa,SAAS,KAAK;AAE1D,OAAI,UAAU,OACZ,OAAM,UAAU;AAGlB,UAAO,UAAU;EAClB;EAED,MAAMC,SAAc,CAAE;AACtB,OAAK,MAAM,OAAO,QAAQ;GACxB,MAAM,OAAO,OAAO;AACpB,OAAI,oBAAoB,mBAAmB,KAAK,EAAE;IAChD,MAAM,QAAQ,wBAAI,MAAM,IAAI;IAC5B,MAAM,YAAY,MAAM,KAAK,aAAa,SAAS,MAAM;AAEzD,QAAI,UAAU,OACZ,OAAM,UAAU;AAGlB,WAAO,OAAO,UAAU;GACzB;EACF;AAED,SAAO;CACR;CAED,YAAmB,OAAOC,gCAAc,UAAU;EAA/B;CAAiC;CAMpD,QAAQC,SAAuB;AAC7B,OAAK,WAAW;AAChB,SAAO;CACR;CAMD,MACEC,OACM;AACN,OAAK,QAAQ,KAAK,MAAM;AACxB,SAAO;CACR;CAED,UACEC,WACsE;AACtE,OAAK,aAAa;AAKlB,SAAO;CAQR;AACF"}

package/dist/Construct-BSEs6uwW.cjs

@@ -0,0 +1,75 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const __geekmidas_envkit = require_chunk.__toESM(require("@geekmidas/envkit"));
+const lodash_compact = require_chunk.__toESM(require("lodash.compact"));
+
+//#region src/Construct.ts
+var Construct = class {
+	constructor(type, logger, services, events = [], publisherService, outputSchema) {
+		this.type = type;
+		this.logger = logger;
+		this.services = services;
+		this.events = events;
+		this.publisherService = publisherService;
+		this.outputSchema = outputSchema;
+	}
+	/**
+	* Returns an array of environment variable names required by this construct's services.
+	* This is determined by running a "sniffer" EnvironmentParser through each service's
+	* register method to track which environment variables are accessed.
+	*
+	* @returns Promise that resolves to array of environment variable names, sorted alphabetically
+	*
+	* @example
+	* ```typescript
+	* const endpoint = e
+	*   .services([databaseService, authService])
+	*   .get('/users')
+	*   .handle(async () => []);
+	*
+	* const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']
+	* ```
+	*/
+	async getEnvironment() {
+		const envVars = /* @__PURE__ */ new Set();
+		const sniffer = new __geekmidas_envkit.EnvironmentParser({});
+		const services = (0, lodash_compact.default)([...this.services, this.publisherService]);
+		try {
+			for (const service of services) try {
+				const config = service.register(sniffer);
+				const resolvedConfig = config && typeof config === "object" && "then" in config ? await Promise.resolve(config) : config;
+				if (resolvedConfig && typeof resolvedConfig === "object" && "getEnvironmentVariables" in resolvedConfig && typeof resolvedConfig.getEnvironmentVariables === "function") {
+					const vars = resolvedConfig.getEnvironmentVariables();
+					if (Array.isArray(vars)) vars.forEach((v) => envVars.add(v));
+				}
+			} catch (serviceError) {
+				continue;
+			}
+			return Array.from(envVars).sort();
+		} catch (error) {
+			console.error("Error determining environment variables for construct:", error);
+			return [];
+		}
+	}
+};
+let ConstructType = /* @__PURE__ */ function(ConstructType$1) {
+	ConstructType$1["Cron"] = "dev.geekmidas.function.cron";
+	ConstructType$1["Endpoint"] = "dev.geekmidas.function.endpoint";
+	ConstructType$1["Function"] = "dev.geekmidas.function.function";
+	ConstructType$1["Subscriber"] = "dev.geekmidas.function.subscriber";
+	return ConstructType$1;
+}({});
+
+//#endregion
+Object.defineProperty(exports, 'Construct', {
+  enumerable: true,
+  get: function () {
+    return Construct;
+  }
+});
+Object.defineProperty(exports, 'ConstructType', {
+  enumerable: true,
+  get: function () {
+    return ConstructType;
+  }
+});
+//# sourceMappingURL=Construct-BSEs6uwW.cjs.map

package/dist/Construct-BSEs6uwW.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct-BSEs6uwW.cjs","names":["type: ConstructType","logger: TLogger","services: TServices","events: MappedEvent<T, any>[]","publisherService?: Service<TServiceName, T>","outputSchema?: OutSchema","EnvironmentParser","services: Service[]","v: string"],"sources":["../src/Construct.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher, MappedEvent } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport compact from 'lodash.compact';\n\nexport abstract class Construct<\n  TLogger extends Logger = Logger,\n  TServiceName extends string = string,\n  T extends EventPublisher<any> | undefined = undefined,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n> {\n  constructor(\n    public readonly type: ConstructType,\n    public readonly logger: TLogger,\n    public readonly services: TServices,\n    public readonly events: MappedEvent<T, any>[] = [],\n\n    public readonly publisherService?: Service<TServiceName, T>,\n    public outputSchema?: OutSchema,\n  ) {}\n\n  /**\n   * Returns an array of environment variable names required by this construct's services.\n   * This is determined by running a \"sniffer\" EnvironmentParser through each service's\n   * register method to track which environment variables are accessed.\n   *\n   * @returns Promise that resolves to array of environment variable names, sorted alphabetically\n   *\n   * @example\n   * ```typescript\n   * const endpoint = e\n   *   .services([databaseService, authService])\n   *   .get('/users')\n   *   .handle(async () => []);\n   *\n   * const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']\n   * ```\n   */\n  async getEnvironment(): Promise<string[]> {\n    const envVars = new Set<string>();\n    const sniffer = new EnvironmentParser({});\n    const services: Service[] = compact([\n      ...this.services,\n      this.publisherService,\n    ]);\n\n    try {\n      // Run each service's register method with the sniffer to track env var access\n      for (const service of services) {\n        try {\n          const config = service.register(sniffer);\n\n          // Await if it's a Promise (async services)\n          const resolvedConfig =\n            config && typeof config === 'object' && 'then' in config\n              ? await Promise.resolve(config)\n              : config;\n\n          // If register returns a ConfigParser, collect its env vars\n          if (\n            resolvedConfig &&\n            typeof resolvedConfig === 'object' &&\n            'getEnvironmentVariables' in resolvedConfig &&\n            typeof resolvedConfig.getEnvironmentVariables === 'function'\n          ) {\n            const vars = resolvedConfig.getEnvironmentVariables();\n            if (Array.isArray(vars)) {\n              vars.forEach((v: string) => envVars.add(v));\n            }\n          }\n        } catch (serviceError) {\n          // Service registration failed (e.g., missing env vars during .parse())\n          // But env vars were already tracked during .create(), so we continue\n          continue;\n        }\n      }\n\n      return Array.from(envVars).sort();\n    } catch (error) {\n      console.error(\n        'Error determining environment variables for construct:',\n        error,\n      );\n\n      return [];\n    }\n  }\n}\n\nexport enum ConstructType {\n  Cron = 'dev.geekmidas.function.cron',\n  Endpoint = 'dev.geekmidas.function.endpoint',\n  Function = 'dev.geekmidas.function.function',\n  Subscriber = 'dev.geekmidas.function.subscriber',\n}\n"],"mappings":";;;;;AAOA,IAAsB,YAAtB,MAME;CACA,YACkBA,MACAC,QACAC,UACAC,SAAgC,CAAE,GAElCC,kBACTC,cACP;EAPgB;EACA;EACA;EACA;EAEA;EACT;CACL;;;;;;;;;;;;;;;;;;CAmBJ,MAAM,iBAAoC;EACxC,MAAM,0BAAU,IAAI;EACpB,MAAM,UAAU,IAAIC,qCAAkB,CAAE;EACxC,MAAMC,WAAsB,4BAAQ,CAClC,GAAG,KAAK,UACR,KAAK,gBACN,EAAC;AAEF,MAAI;AAEF,QAAK,MAAM,WAAW,SACpB,KAAI;IACF,MAAM,SAAS,QAAQ,SAAS,QAAQ;IAGxC,MAAM,iBACJ,iBAAiB,WAAW,YAAY,UAAU,SAC9C,MAAM,QAAQ,QAAQ,OAAO,GAC7B;AAGN,QACE,yBACO,mBAAmB,YAC1B,6BAA6B,yBACtB,eAAe,4BAA4B,YAClD;KACA,MAAM,OAAO,eAAe,yBAAyB;AACrD,SAAI,MAAM,QAAQ,KAAK,CACrB,MAAK,QAAQ,CAACC,MAAc,QAAQ,IAAI,EAAE,CAAC;IAE9C;GACF,SAAQ,cAAc;AAGrB;GACD;AAGH,UAAO,MAAM,KAAK,QAAQ,CAAC,MAAM;EAClC,SAAQ,OAAO;AACd,WAAQ,MACN,0DACA,MACD;AAED,UAAO,CAAE;EACV;CACF;AACF;AAED,IAAY,0DAAL;AACL;AACA;AACA;AACA;;AACD"}

package/dist/Construct-BbKCIPQm.mjs

@@ -0,0 +1,63 @@
+import { EnvironmentParser } from "@geekmidas/envkit";
+import compact from "lodash.compact";
+
+//#region src/Construct.ts
+var Construct = class {
+	constructor(type, logger, services, events = [], publisherService, outputSchema) {
+		this.type = type;
+		this.logger = logger;
+		this.services = services;
+		this.events = events;
+		this.publisherService = publisherService;
+		this.outputSchema = outputSchema;
+	}
+	/**
+	* Returns an array of environment variable names required by this construct's services.
+	* This is determined by running a "sniffer" EnvironmentParser through each service's
+	* register method to track which environment variables are accessed.
+	*
+	* @returns Promise that resolves to array of environment variable names, sorted alphabetically
+	*
+	* @example
+	* ```typescript
+	* const endpoint = e
+	*   .services([databaseService, authService])
+	*   .get('/users')
+	*   .handle(async () => []);
+	*
+	* const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']
+	* ```
+	*/
+	async getEnvironment() {
+		const envVars = /* @__PURE__ */ new Set();
+		const sniffer = new EnvironmentParser({});
+		const services = compact([...this.services, this.publisherService]);
+		try {
+			for (const service of services) try {
+				const config = service.register(sniffer);
+				const resolvedConfig = config && typeof config === "object" && "then" in config ? await Promise.resolve(config) : config;
+				if (resolvedConfig && typeof resolvedConfig === "object" && "getEnvironmentVariables" in resolvedConfig && typeof resolvedConfig.getEnvironmentVariables === "function") {
+					const vars = resolvedConfig.getEnvironmentVariables();
+					if (Array.isArray(vars)) vars.forEach((v) => envVars.add(v));
+				}
+			} catch (serviceError) {
+				continue;
+			}
+			return Array.from(envVars).sort();
+		} catch (error) {
+			console.error("Error determining environment variables for construct:", error);
+			return [];
+		}
+	}
+};
+let ConstructType = /* @__PURE__ */ function(ConstructType$1) {
+	ConstructType$1["Cron"] = "dev.geekmidas.function.cron";
+	ConstructType$1["Endpoint"] = "dev.geekmidas.function.endpoint";
+	ConstructType$1["Function"] = "dev.geekmidas.function.function";
+	ConstructType$1["Subscriber"] = "dev.geekmidas.function.subscriber";
+	return ConstructType$1;
+}({});
+
+//#endregion
+export { Construct, ConstructType };
+//# sourceMappingURL=Construct-BbKCIPQm.mjs.map

package/dist/Construct-BbKCIPQm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct-BbKCIPQm.mjs","names":["type: ConstructType","logger: TLogger","services: TServices","events: MappedEvent<T, any>[]","publisherService?: Service<TServiceName, T>","outputSchema?: OutSchema","services: Service[]","v: string"],"sources":["../src/Construct.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher, MappedEvent } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport compact from 'lodash.compact';\n\nexport abstract class Construct<\n  TLogger extends Logger = Logger,\n  TServiceName extends string = string,\n  T extends EventPublisher<any> | undefined = undefined,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n> {\n  constructor(\n    public readonly type: ConstructType,\n    public readonly logger: TLogger,\n    public readonly services: TServices,\n    public readonly events: MappedEvent<T, any>[] = [],\n\n    public readonly publisherService?: Service<TServiceName, T>,\n    public outputSchema?: OutSchema,\n  ) {}\n\n  /**\n   * Returns an array of environment variable names required by this construct's services.\n   * This is determined by running a \"sniffer\" EnvironmentParser through each service's\n   * register method to track which environment variables are accessed.\n   *\n   * @returns Promise that resolves to array of environment variable names, sorted alphabetically\n   *\n   * @example\n   * ```typescript\n   * const endpoint = e\n   *   .services([databaseService, authService])\n   *   .get('/users')\n   *   .handle(async () => []);\n   *\n   * const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']\n   * ```\n   */\n  async getEnvironment(): Promise<string[]> {\n    const envVars = new Set<string>();\n    const sniffer = new EnvironmentParser({});\n    const services: Service[] = compact([\n      ...this.services,\n      this.publisherService,\n    ]);\n\n    try {\n      // Run each service's register method with the sniffer to track env var access\n      for (const service of services) {\n        try {\n          const config = service.register(sniffer);\n\n          // Await if it's a Promise (async services)\n          const resolvedConfig =\n            config && typeof config === 'object' && 'then' in config\n              ? await Promise.resolve(config)\n              : config;\n\n          // If register returns a ConfigParser, collect its env vars\n          if (\n            resolvedConfig &&\n            typeof resolvedConfig === 'object' &&\n            'getEnvironmentVariables' in resolvedConfig &&\n            typeof resolvedConfig.getEnvironmentVariables === 'function'\n          ) {\n            const vars = resolvedConfig.getEnvironmentVariables();\n            if (Array.isArray(vars)) {\n              vars.forEach((v: string) => envVars.add(v));\n            }\n          }\n        } catch (serviceError) {\n          // Service registration failed (e.g., missing env vars during .parse())\n          // But env vars were already tracked during .create(), so we continue\n          continue;\n        }\n      }\n\n      return Array.from(envVars).sort();\n    } catch (error) {\n      console.error(\n        'Error determining environment variables for construct:',\n        error,\n      );\n\n      return [];\n    }\n  }\n}\n\nexport enum ConstructType {\n  Cron = 'dev.geekmidas.function.cron',\n  Endpoint = 'dev.geekmidas.function.endpoint',\n  Function = 'dev.geekmidas.function.function',\n  Subscriber = 'dev.geekmidas.function.subscriber',\n}\n"],"mappings":";;;;AAOA,IAAsB,YAAtB,MAME;CACA,YACkBA,MACAC,QACAC,UACAC,SAAgC,CAAE,GAElCC,kBACTC,cACP;EAPgB;EACA;EACA;EACA;EAEA;EACT;CACL;;;;;;;;;;;;;;;;;;CAmBJ,MAAM,iBAAoC;EACxC,MAAM,0BAAU,IAAI;EACpB,MAAM,UAAU,IAAI,kBAAkB,CAAE;EACxC,MAAMC,WAAsB,QAAQ,CAClC,GAAG,KAAK,UACR,KAAK,gBACN,EAAC;AAEF,MAAI;AAEF,QAAK,MAAM,WAAW,SACpB,KAAI;IACF,MAAM,SAAS,QAAQ,SAAS,QAAQ;IAGxC,MAAM,iBACJ,iBAAiB,WAAW,YAAY,UAAU,SAC9C,MAAM,QAAQ,QAAQ,OAAO,GAC7B;AAGN,QACE,yBACO,mBAAmB,YAC1B,6BAA6B,yBACtB,eAAe,4BAA4B,YAClD;KACA,MAAM,OAAO,eAAe,yBAAyB;AACrD,SAAI,MAAM,QAAQ,KAAK,CACrB,MAAK,QAAQ,CAACC,MAAc,QAAQ,IAAI,EAAE,CAAC;IAE9C;GACF,SAAQ,cAAc;AAGrB;GACD;AAGH,UAAO,MAAM,KAAK,QAAQ,CAAC,MAAM;EAClC,SAAQ,OAAO;AACd,WAAQ,MACN,0DACA,MACD;AAED,UAAO,CAAE;EACV;CACF;AACF;AAED,IAAY,0DAAL;AACL;AACA;AACA;AACA;;AACD"}

package/dist/Construct-Bm-PSO2V.d.cts

@@ -0,0 +1,42 @@
+import { EventPublisher, MappedEvent } from "@geekmidas/events";
+import { Logger } from "@geekmidas/logger";
+import { Service } from "@geekmidas/services";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/Construct.d.ts
+declare abstract class Construct<TLogger extends Logger = Logger, TServiceName extends string = string, T extends EventPublisher<any> | undefined = undefined, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = []> {
+  readonly type: ConstructType;
+  readonly logger: TLogger;
+  readonly services: TServices;
+  readonly events: MappedEvent<T, any>[];
+  readonly publisherService?: Service<TServiceName, T> | undefined;
+  outputSchema?: OutSchema | undefined;
+  constructor(type: ConstructType, logger: TLogger, services: TServices, events?: MappedEvent<T, any>[], publisherService?: Service<TServiceName, T> | undefined, outputSchema?: OutSchema | undefined);
+  /**
+   * Returns an array of environment variable names required by this construct's services.
+   * This is determined by running a "sniffer" EnvironmentParser through each service's
+   * register method to track which environment variables are accessed.
+   *
+   * @returns Promise that resolves to array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const endpoint = e
+   *   .services([databaseService, authService])
+   *   .get('/users')
+   *   .handle(async () => []);
+   *
+   * const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']
+   * ```
+   */
+  getEnvironment(): Promise<string[]>;
+}
+declare enum ConstructType {
+  Cron = "dev.geekmidas.function.cron",
+  Endpoint = "dev.geekmidas.function.endpoint",
+  Function = "dev.geekmidas.function.function",
+  Subscriber = "dev.geekmidas.function.subscriber",
+}
+//#endregion
+export { Construct, ConstructType };
+//# sourceMappingURL=Construct-Bm-PSO2V.d.cts.map

package/dist/Construct-DIguIyw4.d.mts

@@ -0,0 +1,42 @@
+import { Service } from "@geekmidas/services";
+import { EventPublisher, MappedEvent } from "@geekmidas/events";
+import { Logger } from "@geekmidas/logger";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/Construct.d.ts
+declare abstract class Construct<TLogger extends Logger = Logger, TServiceName extends string = string, T extends EventPublisher<any> | undefined = undefined, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = []> {
+  readonly type: ConstructType;
+  readonly logger: TLogger;
+  readonly services: TServices;
+  readonly events: MappedEvent<T, any>[];
+  readonly publisherService?: Service<TServiceName, T> | undefined;
+  outputSchema?: OutSchema | undefined;
+  constructor(type: ConstructType, logger: TLogger, services: TServices, events?: MappedEvent<T, any>[], publisherService?: Service<TServiceName, T> | undefined, outputSchema?: OutSchema | undefined);
+  /**
+   * Returns an array of environment variable names required by this construct's services.
+   * This is determined by running a "sniffer" EnvironmentParser through each service's
+   * register method to track which environment variables are accessed.
+   *
+   * @returns Promise that resolves to array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const endpoint = e
+   *   .services([databaseService, authService])
+   *   .get('/users')
+   *   .handle(async () => []);
+   *
+   * const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']
+   * ```
+   */
+  getEnvironment(): Promise<string[]>;
+}
+declare enum ConstructType {
+  Cron = "dev.geekmidas.function.cron",
+  Endpoint = "dev.geekmidas.function.endpoint",
+  Function = "dev.geekmidas.function.function",
+  Subscriber = "dev.geekmidas.function.subscriber",
+}
+//#endregion
+export { Construct, ConstructType };
+//# sourceMappingURL=Construct-DIguIyw4.d.mts.map

package/dist/Construct.cjs

@@ -0,0 +1,4 @@
+const require_Construct = require('./Construct-BSEs6uwW.cjs');
+
+exports.Construct = require_Construct.Construct;
+exports.ConstructType = require_Construct.ConstructType;

package/dist/Construct.d.cts

@@ -0,0 +1,2 @@
+import { Construct, ConstructType } from "./Construct-Bm-PSO2V.cjs";
+export { Construct, ConstructType };

package/dist/Construct.d.mts

@@ -0,0 +1,2 @@
+import { Construct, ConstructType } from "./Construct-DIguIyw4.mjs";
+export { Construct, ConstructType };

package/dist/Construct.mjs

@@ -0,0 +1,3 @@
+import { Construct, ConstructType } from "./Construct-BbKCIPQm.mjs";
+
+export { Construct, ConstructType };

package/dist/Cron-Bgs6EQOb.mjs

@@ -0,0 +1,20 @@
+import { ConstructType } from "./Construct-BbKCIPQm.mjs";
+import { Function } from "./Function-C5mW-38v.mjs";
+
+//#region src/crons/Cron.ts
+var Cron = class extends Function {
+	static isCron(obj) {
+		return Boolean(obj && obj.__IS_FUNCTION__ === true && obj.type === ConstructType.Cron);
+	}
+	constructor(fn, timeout, _schedule, input, outputSchema, services = [], logger, publisherService, events = []) {
+		super(fn, timeout, ConstructType.Cron, input, outputSchema, services, logger, publisherService, events);
+		this._schedule = _schedule;
+	}
+	get schedule() {
+		return this._schedule;
+	}
+};
+
+//#endregion
+export { Cron };
+//# sourceMappingURL=Cron-Bgs6EQOb.mjs.map

package/dist/Cron-Bgs6EQOb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron-Bgs6EQOb.mjs","names":["obj: any","fn: FunctionHandler<TInput, TServices, TLogger, OutSchema>","timeout?: number","_schedule?: ScheduleExpression","input?: TInput","outputSchema?: OutSchema","services: TServices","logger?: TLogger","publisherService?: Service<TEventPublisherServiceName, TEventPublisher>","events: any[]"],"sources":["../src/crons/Cron.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\n\nimport { ConstructType } from '../Construct';\nimport { Function, type FunctionHandler } from '../functions';\n\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { ComposableStandardSchema } from '@geekmidas/schema';\nimport type { Service } from '@geekmidas/services';\n\nexport class Cron<\n  TInput extends ComposableStandardSchema | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> extends Function<\n  TInput,\n  TServices,\n  TLogger,\n  OutSchema,\n  FunctionHandler<TInput, TServices, TLogger, OutSchema>,\n  TEventPublisher,\n  TEventPublisherServiceName\n> {\n  static isCron(obj: any): obj is Cron<any, any, any, any> {\n    return Boolean(\n      obj &&\n        (obj as Function).__IS_FUNCTION__ === true &&\n        obj.type === ConstructType.Cron,\n    );\n  }\n\n  constructor(\n    fn: FunctionHandler<TInput, TServices, TLogger, OutSchema>,\n    timeout?: number,\n    protected _schedule?: ScheduleExpression,\n    input?: TInput,\n    outputSchema?: OutSchema,\n    services: TServices = [] as unknown as TServices,\n    logger?: TLogger,\n    publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,\n    events: any[] = [],\n  ) {\n    super(\n      fn,\n      timeout,\n      ConstructType.Cron,\n      input,\n      outputSchema,\n      services,\n      logger,\n      publisherService,\n      events,\n    );\n  }\n\n  get schedule(): ScheduleExpression | undefined {\n    return this._schedule;\n  }\n}\n\nexport type RateExpression = `rate(${string})`;\n\ntype CronMinute =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | `${number},${number}`\n  | string; // Allow more complex patterns\n\ntype CronHour =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | `${number},${number}`\n  | string; // Allow more complex patterns\n\ntype CronDay =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | `${number},${number}`\n  | string; // Allow more complex patterns\n\ntype CronMonth =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | 'JAN'\n  | 'FEB'\n  | 'MAR'\n  | 'APR'\n  | 'MAY'\n  | 'JUN'\n  | 'JUL'\n  | 'AUG'\n  | 'SEP'\n  | 'OCT'\n  | 'NOV'\n  | 'DEC'\n  | string; // Allow more complex patterns\n\ntype CronWeekday =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | 'SUN'\n  | 'MON'\n  | 'TUE'\n  | 'WED'\n  | 'THU'\n  | 'FRI'\n  | 'SAT'\n  | `${string}-${string}` // Allow patterns like MON-FRI\n  | string; // Allow more complex patterns\n\nexport type CronExpression =\n  `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;\n\nexport type ScheduleExpression = RateExpression | CronExpression;\n"],"mappings":";;;;AAUA,IAAa,OAAb,cAOU,SAQR;CACA,OAAO,OAAOA,KAA2C;AACvD,SAAO,QACL,OACG,IAAiB,oBAAoB,QACtC,IAAI,SAAS,cAAc,KAC9B;CACF;CAED,YACEC,IACAC,SACUC,WACVC,OACAC,cACAC,WAAsB,CAAE,GACxBC,QACAC,kBACAC,SAAgB,CAAE,GAClB;AACA,QACE,IACA,SACA,cAAc,MACd,OACA,cACA,UACA,QACA,kBACA,OACD;EAlBS;CAmBX;CAED,IAAI,WAA2C;AAC7C,SAAO,KAAK;CACb;AACF"}

package/dist/Cron-DQiCj3ef.cjs

@@ -0,0 +1,25 @@
+const require_Construct = require('./Construct-BSEs6uwW.cjs');
+const require_Function = require('./Function-CbO2NZx-.cjs');
+
+//#region src/crons/Cron.ts
+var Cron = class extends require_Function.Function {
+	static isCron(obj) {
+		return Boolean(obj && obj.__IS_FUNCTION__ === true && obj.type === require_Construct.ConstructType.Cron);
+	}
+	constructor(fn, timeout, _schedule, input, outputSchema, services = [], logger, publisherService, events = []) {
+		super(fn, timeout, require_Construct.ConstructType.Cron, input, outputSchema, services, logger, publisherService, events);
+		this._schedule = _schedule;
+	}
+	get schedule() {
+		return this._schedule;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Cron', {
+  enumerable: true,
+  get: function () {
+    return Cron;
+  }
+});
+//# sourceMappingURL=Cron-DQiCj3ef.cjs.map

package/dist/Cron-DQiCj3ef.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron-DQiCj3ef.cjs","names":["Function","obj: any","ConstructType","fn: FunctionHandler<TInput, TServices, TLogger, OutSchema>","timeout?: number","_schedule?: ScheduleExpression","input?: TInput","outputSchema?: OutSchema","services: TServices","logger?: TLogger","publisherService?: Service<TEventPublisherServiceName, TEventPublisher>","events: any[]"],"sources":["../src/crons/Cron.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\n\nimport { ConstructType } from '../Construct';\nimport { Function, type FunctionHandler } from '../functions';\n\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { ComposableStandardSchema } from '@geekmidas/schema';\nimport type { Service } from '@geekmidas/services';\n\nexport class Cron<\n  TInput extends ComposableStandardSchema | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> extends Function<\n  TInput,\n  TServices,\n  TLogger,\n  OutSchema,\n  FunctionHandler<TInput, TServices, TLogger, OutSchema>,\n  TEventPublisher,\n  TEventPublisherServiceName\n> {\n  static isCron(obj: any): obj is Cron<any, any, any, any> {\n    return Boolean(\n      obj &&\n        (obj as Function).__IS_FUNCTION__ === true &&\n        obj.type === ConstructType.Cron,\n    );\n  }\n\n  constructor(\n    fn: FunctionHandler<TInput, TServices, TLogger, OutSchema>,\n    timeout?: number,\n    protected _schedule?: ScheduleExpression,\n    input?: TInput,\n    outputSchema?: OutSchema,\n    services: TServices = [] as unknown as TServices,\n    logger?: TLogger,\n    publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,\n    events: any[] = [],\n  ) {\n    super(\n      fn,\n      timeout,\n      ConstructType.Cron,\n      input,\n      outputSchema,\n      services,\n      logger,\n      publisherService,\n      events,\n    );\n  }\n\n  get schedule(): ScheduleExpression | undefined {\n    return this._schedule;\n  }\n}\n\nexport type RateExpression = `rate(${string})`;\n\ntype CronMinute =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | `${number},${number}`\n  | string; // Allow more complex patterns\n\ntype CronHour =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | `${number},${number}`\n  | string; // Allow more complex patterns\n\ntype CronDay =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | `${number},${number}`\n  | string; // Allow more complex patterns\n\ntype CronMonth =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | 'JAN'\n  | 'FEB'\n  | 'MAR'\n  | 'APR'\n  | 'MAY'\n  | 'JUN'\n  | 'JUL'\n  | 'AUG'\n  | 'SEP'\n  | 'OCT'\n  | 'NOV'\n  | 'DEC'\n  | string; // Allow more complex patterns\n\ntype CronWeekday =\n  | '*'\n  | number\n  | `${number}`\n  | `${number}-${number}`\n  | `${number}/${number}`\n  | `*/${number}`\n  | 'SUN'\n  | 'MON'\n  | 'TUE'\n  | 'WED'\n  | 'THU'\n  | 'FRI'\n  | 'SAT'\n  | `${string}-${string}` // Allow patterns like MON-FRI\n  | string; // Allow more complex patterns\n\nexport type CronExpression =\n  `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;\n\nexport type ScheduleExpression = RateExpression | CronExpression;\n"],"mappings":";;;;AAUA,IAAa,OAAb,cAOUA,0BAQR;CACA,OAAO,OAAOC,KAA2C;AACvD,SAAO,QACL,OACG,IAAiB,oBAAoB,QACtC,IAAI,SAASC,gCAAc,KAC9B;CACF;CAED,YACEC,IACAC,SACUC,WACVC,OACAC,cACAC,WAAsB,CAAE,GACxBC,QACAC,kBACAC,SAAgB,CAAE,GAClB;AACA,QACE,IACA,SACAT,gCAAc,MACd,OACA,cACA,UACA,QACA,kBACA,OACD;EAlBS;CAmBX;CAED,IAAI,WAA2C;AAC7C,SAAO,KAAK;CACb;AACF"}