@geekmidas/constructs 10.0.0-alpha.12 → 10.0.0-alpha.121

package/dist/index-DdRjYhiJ.d.cts

@@ -0,0 +1,119 @@
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+export { StandardSchemaV1 as n, StandardJSONSchemaV1 as t };
+//# sourceMappingURL=index-DdRjYhiJ.d.cts.map

package/dist/index-DdRjYhiJ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DdRjYhiJ.d.cts","names":[],"sources":["../../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;UACU,gBAAgB,iBAAiB,SAAS;;WAEvC,aAAa,gBAAgB,MAAM,OAAO;;kBAErC;;YAEJ,MAAM,iBAAiB,SAAS;;aAE7B;;aAEA;;aAEA,QAAQ,MAAM,OAAO;;;YAGxB,MAAM,iBAAiB,SAAS;;aAE7B,OAAO;;aAEP,QAAQ;;;OAGhB,WAAW,eAAe,mBAAmB,YAAY;;OAEzD,YAAY,eAAe,mBAAmB,YAAY;;;UAGzD,iBAAiB,iBAAiB,SAAS;;WAExC,aAAa,iBAAiB,MAAM,OAAO;;kBAEtC;;YAEJ,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;aAEzE,WAAW,gBAAgB,UAAU,iBAAiB,wBAAwB,OAAO,UAAU,QAAQ,OAAO;;;OAGtH,OAAO,UAAU,cAAc,UAAU;;YAEpC,cAAc;;aAEX,OAAO;;aAEP;;YAEH;;aAEG,iBAAiB;;;YAGpB;;aAEG,QAAQ,cAAc;;;YAGzB;;aAEG;;aAEA,OAAO,cAAc,cAAc;;;YAGtC;;aAEG,KAAK;;;YAGR,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;OAGjF,WAAW,eAAe,mBAAmB,gBAAgB,WAAW;;OAExE,YAAY,eAAe,mBAAmB,gBAAgB,YAAY;;;UAGzE,qBAAqB,iBAAiB,SAAS;;WAE5C,aAAa,qBAAqB,MAAM,OAAO;;kBAE1C;;YAEJ,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;aAEzE,YAAY,qBAAqB;;;YAGpC;;aAEG,QAAQ,SAAS,qBAAqB,YAAY;;aAElD,SAAS,SAAS,qBAAqB,YAAY;;;;;;;;;OAS3D;;YAEK;;aAEG,QAAQ;;aAER,iBAAiB;;;YAGpB,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;OAGjF,WAAW,eAAe,mBAAmB,gBAAgB,WAAW;;OAExE,YAAY,eAAe,mBAAmB,gBAAgB,YAAY"}

package/dist/index-DdRjYhiJ.d.mts

@@ -0,0 +1,119 @@
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+export { StandardSchemaV1 as n, StandardJSONSchemaV1 as t };
+//# sourceMappingURL=index-DdRjYhiJ.d.mts.map

package/dist/index-DdRjYhiJ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DdRjYhiJ.d.mts","names":[],"sources":["../../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;UACU,gBAAgB,iBAAiB,SAAS;;WAEvC,aAAa,gBAAgB,MAAM,OAAO;;kBAErC;;YAEJ,MAAM,iBAAiB,SAAS;;aAE7B;;aAEA;;aAEA,QAAQ,MAAM,OAAO;;;YAGxB,MAAM,iBAAiB,SAAS;;aAE7B,OAAO;;aAEP,QAAQ;;;OAGhB,WAAW,eAAe,mBAAmB,YAAY;;OAEzD,YAAY,eAAe,mBAAmB,YAAY;;;UAGzD,iBAAiB,iBAAiB,SAAS;;WAExC,aAAa,iBAAiB,MAAM,OAAO;;kBAEtC;;YAEJ,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;aAEzE,WAAW,gBAAgB,UAAU,iBAAiB,wBAAwB,OAAO,UAAU,QAAQ,OAAO;;;OAGtH,OAAO,UAAU,cAAc,UAAU;;YAEpC,cAAc;;aAEX,OAAO;;aAEP;;YAEH;;aAEG,iBAAiB;;;YAGpB;;aAEG,QAAQ,cAAc;;;YAGzB;;aAEG;;aAEA,OAAO,cAAc,cAAc;;;YAGtC;;aAEG,KAAK;;;YAGR,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;OAGjF,WAAW,eAAe,mBAAmB,gBAAgB,WAAW;;OAExE,YAAY,eAAe,mBAAmB,gBAAgB,YAAY;;;UAGzE,qBAAqB,iBAAiB,SAAS;;WAE5C,aAAa,qBAAqB,MAAM,OAAO;;kBAE1C;;YAEJ,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;aAEzE,YAAY,qBAAqB;;;YAGpC;;aAEG,QAAQ,SAAS,qBAAqB,YAAY;;aAElD,SAAS,SAAS,qBAAqB,YAAY;;;;;;;;;OAS3D;;YAEK;;aAEG,QAAQ;;aAER,iBAAiB;;;YAGpB,MAAM,iBAAiB,SAAS,eAAe,gBAAgB,MAAM,OAAO;;OAGjF,WAAW,eAAe,mBAAmB,gBAAgB,WAAW;;OAExE,YAAY,eAAe,mBAAmB,gBAAgB,YAAY"}

package/dist/index-aBIcAiH5.d.mts

@@ -0,0 +1,115 @@
+import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.mjs";
+import { a as EventFor, c as Topic, n as ConstructType, o as TopicEvent } from "./Construct-B7AXn0xH.mjs";
+import { i as FunctionHandler, n as Function } from "./Function-B_9R7Zy1.mjs";
+import { c as ServicesOf, r as Consumable } from "./construct-interface-ZvYQbivO.mjs";
+import { Service } from "@geekmidas/services";
+import { AuditStorage, AuditableAction } from "@geekmidas/audit";
+import { Logger } from "@geekmidas/logger";
+import { ComposableStandardSchema, InferComposableStandardSchema, InferStandardSchema } 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, TAuditStorage extends AuditStorage | undefined = undefined, TAuditStorageServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string> {
+  type: ConstructType;
+  protected inputSchema?: TInput;
+  protected outputSchema?: OutSchema;
+  protected _timeout?: number;
+  _services: TServices;
+  /**
+   * The construct ids `.dependsOn()` was given.
+   *
+   * Beside the services rather than instead of them: a handler *runs* with
+   * clients and the manifest *records* which constructs it reaches, and
+   * dissolving one into the other is what lost the edges. Shared by every
+   * builder because every one of them can depend on something.
+   */
+  _constructs: string[];
+  _logger: TLogger;
+  /**
+   * The deploy unit everything built from this builder belongs to.
+   *
+   * Seeded by the factory a `Worker` or `RestApi` hands out, so a cron knows
+   * which process runs it without a directory having to imply it.
+   */
+  _owner?: string;
+  /**
+   * Where a cron built from this factory keeps its schedule.
+   *
+   * Set by the worker that handed the factory out, the same way the logger
+   * and the owner are — so a cron file names a schedule and nothing else.
+   * Only a server target reads it; on AWS the schedule is an EventBridge rule.
+   */
+  _scheduleStore?: unknown;
+  /** What the built construct publishes, each event bound to its topic. */
+  _events: TopicEvent[];
+  protected _auditorStorage?: Service<TAuditStorageServiceName, TAuditStorage>;
+  protected _databaseService?: Service<TDatabaseServiceName, TDatabase>;
+  /** The edge `.database()` added, so the next one can replace it. */
+  protected _databaseEdge?: string;
+  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;
+  /**
+   * A clone that publishes `event` to `topic` once the handler succeeds, and
+   * has the topic as a dependency the way `.dependsOn([topic])` would: in
+   * `services`, and an edge in the manifest. Each builder types it as its own
+   * `event()`, since only it knows how its services widen.
+   */
+  protected withEvent(topic: Topic<any, any>, event: EventFor<Topic<any, any>, any>): this;
+  auditor<T extends AuditStorage, TName extends string>(storage: Service<TName, T>): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName, TDatabase, TDatabaseServiceName>;
+  /**
+   * Set the database service for this function.
+   * The database will be available in the handler context as `db`.
+   */
+  database<T, TName extends string>(source: Consumable<TName, T> | Service<TName, T>): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, TAuditStorage, TAuditStorageServiceName, T, TName>;
+}
+//#endregion
+//#region src/functions/FunctionBuilder.d.ts
+declare class FunctionBuilder<TInput extends ComposableStandardSchema, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, TAuditStorage extends AuditStorage | undefined = undefined, TAuditStorageServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string, TAuditAction extends AuditableAction<string, unknown> = AuditableAction<string, unknown>> extends BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName> {
+  type: ConstructType;
+  protected _memorySize?: number;
+  constructor(type?: ConstructType);
+  timeout(timeout: number): this;
+  memorySize(memorySize: number): this;
+  output<T extends StandardSchemaV1>(schema: T): FunctionBuilder<TInput, T, TServices, TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  input<T extends ComposableStandardSchema>(schema: T): FunctionBuilder<T, OutSchema, TServices, TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  /**
+   * Depend on constructs — a database, a bucket, a mail sender, a queue, a
+   * topic.
+   *
+   * It records the edge and dissolves each construct's client into the
+   * handler's service record under the construct's own id, so
+   * `.dependsOn([uploads])` is what makes `services.uploads` exist and type.
+   *
+   * Constructs only. A `Service` does not match the shape, which is what keeps
+   * env sniffing confined to `.services()` and the explicit lift.
+   */
+  dependsOn<const T extends readonly Consumable[]>(constructs: T): FunctionBuilder<TInput, OutSchema, [...TServices, ...ServicesOf<T>], TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  services<T extends Service[]>(services: T): FunctionBuilder<TInput, OutSchema, [...TServices, ...T], TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  logger<T extends Logger>(logger: T): FunctionBuilder<TInput, OutSchema, TServices, T, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  /**
+   * Publish `event` to `topic` once the function has succeeded — repeatable,
+   * one call per event, to as many topics as it names. The topic becomes a
+   * dependency as with `.dependsOn([topic])`, so `services.<topic>` is there
+   * for events the handler decides on itself.
+   */
+  event<TTopic extends Topic<any, any>>(topic: TTopic, event: EventFor<TTopic, InferStandardSchema<OutSchema>>): FunctionBuilder<TInput, OutSchema, [...TServices, TTopic['service']], TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  auditor<T extends AuditStorage, TName extends string>(storage: Service<TName, T>): FunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName, TDatabase, TDatabaseServiceName, TAuditAction>;
+  /**
+   * Set the audit action types for this function.
+   * This provides type-safety for the auditor in the handler context.
+   */
+  actions<T extends AuditableAction<string, unknown>>(): FunctionBuilder<TInput, OutSchema, TServices, TLogger, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, T>;
+  /**
+   * Set the database service for this function.
+   * The database will be available in the handler context as `db`.
+   */
+  database<T, TName extends string>(source: Consumable<TName, T> | Service<TName, T>): FunctionBuilder<TInput, OutSchema, TServices, TLogger, TAuditStorage, TAuditStorageServiceName, T, TName, TAuditAction>;
+  handle(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase, TAuditStorage, TAuditAction>): Function<TInput, TServices, TLogger, OutSchema, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase, TAuditStorage, TAuditAction>>;
+}
+//#endregion
+export { BaseFunctionBuilder as n, FunctionBuilder as t };
+//# sourceMappingURL=index-aBIcAiH5.d.mts.map

package/dist/index-aBIcAiH5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-aBIcAiH5.d.mts","names":[],"sources":["../src/functions/BaseFunctionBuilder.ts","../src/functions/FunctionBuilder.ts"],"mappings":";;;;;;;;;uBAsBsB,oBACrB,eAAe,0BACf,kBAAkB,0CAClB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,sBAAsB,sCACtB,kDACA,uBACA;EAoFmB,MAAI;YAlFb,cAAc;YACd,eAAe;YACf;EAEH,WAAW;;;;;;;;;EASX;EACA,SAAS;;;;;;;EAQT;;;;;;;;EASA;;EAGA,SAAS;YACN,kBAAkB,QAAQ,0BAA0B;YACpD,mBAAmB,QAAQ,sBAAsB;;YAEjD;SAEH,mBAAmB,aAAa,KAAK;SAM/B,8BACZ,UAAU,sCACT,eAAe,QAAQ,IAAI,QAAQ,8BAA8B;EAkCnE,YAAmB,OAAI;WAEd,SAAS,UAAU,WAAW,UAAU;WAExC,OAAO,UAAU,QAAQ,QAAQ;EAE1C,QAAQ;WAIC,OAAO,UAAU,kBAAkB,QAAQ;WAE3C,MAAM,UAAU,0BAA0B,QAAQ;;;;;;;YAQjD,UACT,OAAO,iBACP,OAAO,SAAS;EAcjB,QAAQ,UAAU,cAAc,sBAC/B,SAAS,QAAQ,OAAO,KACtB,oBACF,QACA,WACA,WACA,SACA,GACA,OACA,WACA;;;;;EAuBD,SAAS,GAAG,sBACX,QAAQ,WAAW,OAAO,KAAK,QAAQ,OAAO,KAC5C,oBACF,QACA,WACA,WACA,SACA,eACA,0BACA,GACA;;;;cCzKW,gBACZ,eAAe,0BACf,kBAAkB,0CAClB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,sBAAsB,sCACtB,kDACA,uBACA,8CACA,qBAAqB,mCAAmC,0CAI/C,oBACT,QACA,WACA,WACA,SACA,eACA,0BACA,WACA;EAI4B,MAAI;YAFtB;EAEV,YAA4B,OAAI;EAIvB,QAAQ;EAIjB,WAAW;EAIX,OAAO,UAAU,kBAChB,QAAQ,IACN,gBACF,QACA,GACA,WACA,SACA,eACA,0BACA,WACA,sBACA;EAiBD,MAAM,UAAU,0BACf,QAAQ,IACN,gBACF,GACA,WACA,WACA,SACA,eACA,0BACA,WACA,sBACA;;;;;;;;;;;;EA4BD,gBAAgB,mBAAmB,cAClC,YAAY,IACV,gBACF,QACA,eACI,cAAc,WAAW,KAC7B,SACA,eACA,0BACA,WACA,sBACA;EA8BD,SAAS,UAAU,WAClB,UAAU,IACR,gBACF,QACA,eACI,cAAc,IAClB,SACA,eACA,0BACA,WACA,sBACA;EAoBD,OAAO,UAAU,QAChB,QAAQ,IACN,gBACF,QACA,WACA,WACA,GACA,eACA,0BACA,WACA,sBACA;;;;;;;EAuBD,MAAM,eAAe,iBACpB,OAAO,QACP,OAAO,SAAS,QAAQ,oBAAoB,cAC1C,gBACF,QACA,eACI,WAAW,oBACf,SACA,eACA,0BACA,WACA,sBACA;EAeQ,QAAQ,UAAU,cAAc,sBACxC,SAAS,QAAQ,OAAO,KACtB,gBACF,QACA,WACA,WACA,SACA,GACA,OACA,WACA,sBACA;;;;;EAwBD,QAAQ,UAAU,qCAAqC,gBACtD,QACA,WACA,WACA,SACA,eACA,0BACA,WACA,sBACA;;;;;EAmBQ,SAAS,GAAG,sBACpB,QAAQ,WAAW,OAAO,KAAK,QAAQ,OAAO,KAC5C,gBACF,QACA,WACA,WACA,SACA,eACA,0BACA,GACA,OACA;EAkCD,OACC,IAAI,gBACH,QACA,WACA,SACA,WACA,WACA,eACA,gBAEC,SACF,QACA,WACA,SACA,WACA,eACA,0BACA,WACA,sBACA,cACA,gBACC,QACA,WACA,SACA,WACA,WACA,eACA"}

package/dist/index.cjs

@@ -1,6 +1,9 @@
-const require_Construct = require('./Construct-CyS3RpTL.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_Construct = require("./Construct-DEOVauyA.cjs");
+const require_shutdown = require("./shutdown-BMJmAhSt.cjs");
 exports.Construct = require_Construct.Construct;
 exports.ConstructType = require_Construct.ConstructType;
+exports.onShutdown = require_shutdown.onShutdown;
+exports.runShutdownHooks = require_shutdown.runShutdownHooks;
 exports.sniffService = require_Construct.sniffService;
-exports.snifferContext = require_Construct.snifferContext;
+exports.snifferContext = require_Construct.snifferContext;

package/dist/index.d.cts

@@ -1,5 +1,28 @@
-import { Construct, ConstructType, sniffService, snifferContext } from "./Construct-C0ijr2qp.cjs";
-import { HttpMethod, LowerHttpMethod, RemoveUndefined } from "./types-BlAkSuGI.cjs";
-import { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse } from "./telemetry-C3L0iS28.cjs";
+import { i as snifferContext, n as ConstructType, r as sniffService, t as Construct } from "./Construct-CFW0zjdD.cjs";
+import { n as LowerHttpMethod, r as RemoveUndefined, t as HttpMethod } from "./types-DMuSQeLL.cjs";
+import { i as TelemetryResponse, n as TelemetryContext, r as TelemetryRequest, t as Telemetry } from "./lambdaTelemetry-8vnmVZQ5.cjs";
+import { a as Stages, i as SeedContext, n as DeployedStage, o as TestStage, r as LocalStage, t as AnyStage } from "./stages-BSCF19o2.cjs";
 import { Service, ServiceRecord } from "@geekmidas/services";
-export { Construct, ConstructType, HttpMethod, LowerHttpMethod, RemoveUndefined, Service, ServiceRecord, Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse, sniffService, snifferContext };
+//#region src/shutdown.d.ts
+/**
+ * What a server releases when it stops: the connections constructs opened.
+ *
+ * A construct that holds something open — a database's pool — registers how to
+ * close it here, and the generated server runs every hook once it has stopped
+ * taking requests. Without that, a rolling deploy has the old task and the new
+ * one both holding connections until the old process dies.
+ *
+ * Kept free of any driver import so the server entry can always import it,
+ * whether or not the app has a database.
+ */
+type ShutdownHook = () => Promise<void> | void;
+/** Run `hook` when the server shuts down. Returns a function that removes it. */
+export declare function onShutdown(hook: ShutdownHook): () => void;
+/**
+ * Run every registered hook, together, and wait for them. A hook that fails is
+ * reported to `onError` and does not stop the others.
+ */
+export declare function runShutdownHooks(onError?: (error: unknown) => void): Promise<void>;
+//#endregion
+export { type AnyStage, Construct, ConstructType, type DeployedStage, type HttpMethod, type LocalStage, type LowerHttpMethod, type RemoveUndefined, type SeedContext, type Service, type ServiceRecord, type Stages, type Telemetry, type TelemetryContext, type TelemetryRequest, type TelemetryResponse, type TestStage, sniffService, snifferContext };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/shutdown.ts"],"mappings":";;;;;;;;;;;;;;;;;KAYK,qBAAqB;;wBAUV,WAAW,MAAM;;;;;wBASX,iBACrB,WAAU,0BACR"}

package/dist/index.d.mts

@@ -1,5 +1,28 @@
-import { Construct, ConstructType, sniffService, snifferContext } from "./Construct-Ct8nalEi.mjs";
-import { HttpMethod, LowerHttpMethod, RemoveUndefined } from "./types-aKksMEWL.mjs";
-import { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse } from "./telemetry-D7bVFLGi.mjs";
+import { i as snifferContext, n as ConstructType, r as sniffService, t as Construct } from "./Construct-B7AXn0xH.mjs";
+import { n as LowerHttpMethod, r as RemoveUndefined, t as HttpMethod } from "./types-DMuSQeLL.mjs";
+import { i as TelemetryResponse, n as TelemetryContext, r as TelemetryRequest, t as Telemetry } from "./lambdaTelemetry-8vnmVZQ5.mjs";
+import { a as Stages, i as SeedContext, n as DeployedStage, o as TestStage, r as LocalStage, t as AnyStage } from "./stages-BSCF19o2.mjs";
 import { Service, ServiceRecord } from "@geekmidas/services";
-export { Construct, ConstructType, HttpMethod, LowerHttpMethod, RemoveUndefined, Service, ServiceRecord, Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse, sniffService, snifferContext };
+//#region src/shutdown.d.ts
+/**
+ * What a server releases when it stops: the connections constructs opened.
+ *
+ * A construct that holds something open — a database's pool — registers how to
+ * close it here, and the generated server runs every hook once it has stopped
+ * taking requests. Without that, a rolling deploy has the old task and the new
+ * one both holding connections until the old process dies.
+ *
+ * Kept free of any driver import so the server entry can always import it,
+ * whether or not the app has a database.
+ */
+type ShutdownHook = () => Promise<void> | void;
+/** Run `hook` when the server shuts down. Returns a function that removes it. */
+export declare function onShutdown(hook: ShutdownHook): () => void;
+/**
+ * Run every registered hook, together, and wait for them. A hook that fails is
+ * reported to `onError` and does not stop the others.
+ */
+export declare function runShutdownHooks(onError?: (error: unknown) => void): Promise<void>;
+//#endregion
+export { type AnyStage, Construct, ConstructType, type DeployedStage, type HttpMethod, type LocalStage, type LowerHttpMethod, type RemoveUndefined, type SeedContext, type Service, type ServiceRecord, type Stages, type Telemetry, type TelemetryContext, type TelemetryRequest, type TelemetryResponse, type TestStage, sniffService, snifferContext };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/shutdown.ts"],"mappings":";;;;;;;;;;;;;;;;;KAYK,qBAAqB;;wBAUV,WAAW,MAAM;;;;;wBASX,iBACrB,WAAU,0BACR"}

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { Construct, ConstructType, sniffService, snifferContext } from "./Construct-BD5neF7w.mjs";
-
-export { Construct, ConstructType, sniffService, snifferContext };
+import { i as snifferContext, n as ConstructType, r as sniffService, t as Construct } from "./Construct-CKUA-CTA.mjs";
+import { n as runShutdownHooks, t as onShutdown } from "./shutdown-C7xa8x9S.mjs";
+export { Construct, ConstructType, onShutdown, runShutdownHooks, sniffService, snifferContext };