@geekmidas/constructs 10.0.0-alpha.3 → 10.0.0-alpha.31

package/dist/index-CeEtxDmK.d.mts

@@ -0,0 +1,79 @@
+//#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>;
+}
+//#endregion
+export { StandardSchemaV1 as t };
+//# sourceMappingURL=index-CeEtxDmK.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CeEtxDmK.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"}

package/dist/index-fnpjXiA-.d.mts

@@ -0,0 +1,26 @@
+import { n as TopicEvents, t as Topic } from "./Topic-DVvheJ_-.mjs";
+import { Logger } from "@geekmidas/logger";
+//#region src/topic/TopicBuilder.d.ts
+/**
+ * Builds a {@link Topic} — `t.topic('users').events({ 'user.created': schema, … })`.
+ * The event map is the topic's contract: it types the derived `topic.publisher`
+ * and the subscribers that bind via `s.topic(topic)`.
+ */
+declare class TopicBuilder<TName extends string = string, TEvents extends TopicEvents = TopicEvents> {
+  private _name?;
+  private _logger;
+  /** The topic name — drives the infra topic and its `<NAME>_*` env vars. */
+  topic<T extends string>(name: T): TopicBuilder<T, TEvents>;
+  logger(logger: Logger): this;
+  /**
+   * The event contract — a map of event type → payload schema. Building the
+   * topic requires this; it's what types the publisher and subscribers.
+   */
+  events<T extends TopicEvents>(events: T): Topic<TName, T>;
+}
+//#endregion
+//#region src/topic/index.d.ts
+export declare const t: TopicBuilder<string, TopicEvents>;
+//#endregion
+export { TopicBuilder as n };
+//# sourceMappingURL=index-fnpjXiA-.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-fnpjXiA-.d.mts","names":["_$__Topic0.TopicEvents"],"sources":["../src/topic/TopicBuilder.ts","../src/topic/index.ts"],"mappings":";;;;;;;;cAUa,aACZ,+BACA,gBAAgB,cAAc;UAEtB;UACA;;EAGR,MAAM,kBAAkB,MAAM,IAAI,aAAa,GAAG;EAOlD,OAAO,QAAQ;;;;;EAQf,OAAO,UAAU,aAAa,QAAQ,IAAI,MAAM,OAAO;;;;qBCvB3C,GAAC,qBAADA"}

package/dist/index-tE_119SX.d.cts

@@ -0,0 +1,26 @@
+import { n as TopicEvents, t as Topic } from "./Topic-D6blllEn.cjs";
+import { Logger } from "@geekmidas/logger";
+//#region src/topic/TopicBuilder.d.ts
+/**
+ * Builds a {@link Topic} — `t.topic('users').events({ 'user.created': schema, … })`.
+ * The event map is the topic's contract: it types the derived `topic.publisher`
+ * and the subscribers that bind via `s.topic(topic)`.
+ */
+declare class TopicBuilder<TName extends string = string, TEvents extends TopicEvents = TopicEvents> {
+  private _name?;
+  private _logger;
+  /** The topic name — drives the infra topic and its `<NAME>_*` env vars. */
+  topic<T extends string>(name: T): TopicBuilder<T, TEvents>;
+  logger(logger: Logger): this;
+  /**
+   * The event contract — a map of event type → payload schema. Building the
+   * topic requires this; it's what types the publisher and subscribers.
+   */
+  events<T extends TopicEvents>(events: T): Topic<TName, T>;
+}
+//#endregion
+//#region src/topic/index.d.ts
+export declare const t: TopicBuilder<string, TopicEvents>;
+//#endregion
+export { TopicBuilder as n };
+//# sourceMappingURL=index-tE_119SX.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-tE_119SX.d.cts","names":["_$__Topic0.TopicEvents"],"sources":["../src/topic/TopicBuilder.ts","../src/topic/index.ts"],"mappings":";;;;;;;;cAUa,aACZ,+BACA,gBAAgB,cAAc;UAEtB;UACA;;EAGR,MAAM,kBAAkB,MAAM,IAAI,aAAa,GAAG;EAOlD,OAAO,QAAQ;;;;;EAQf,OAAO,UAAU,aAAa,QAAQ,IAAI,MAAM,OAAO;;;;qBCvB3C,GAAC,qBAADA"}

package/dist/{index-CubPzHd9.d.mts → index-yb3fXNyH.d.mts}

@@ -1,21 +1,16 @@
-import { Construct, ConstructType } from "./Construct-Ct8nalEi.mjs";
-import { Consumable, ServicesOf } from "./construct-interface-g5GM5pwR.mjs";
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
+import { n as ConstructType, t as Construct } from "./Construct-pVadmURD.mjs";
+import { c as ServicesOf, r as Consumable } from "./construct-interface-D2gesxos.mjs";
+import { EventPublisher, MappedEvent } from "@geekmidas/events";
 import { Service, ServiceRecord } from "@geekmidas/services";
-import * as _geekmidas_audit23 from "@geekmidas/audit";
 import { AuditStorage, AuditableAction, Auditor } from "@geekmidas/audit";
-import { EventPublisher, MappedEvent } from "@geekmidas/events";
-import * as _geekmidas_logger22 from "@geekmidas/logger";
 import { Logger } from "@geekmidas/logger";
-import * as _geekmidas_schema21 from "@geekmidas/schema";
 import { ComposableStandardSchema, InferComposableStandardSchema, InferStandardSchema } from "@geekmidas/schema";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/functions/Function.d.ts
-
 declare class Function<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TEventPublisher extends EventPublisher<any> | undefined = undefined, TEventPublisherServiceName extends string = string, TAuditStorage extends AuditStorage | undefined = undefined, TAuditStorageServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string, TAuditAction extends AuditableAction<string, unknown> = AuditableAction<string, unknown>, Fn extends FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase, TAuditStorage, TAuditAction> = FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase, TAuditStorage, TAuditAction>> extends Construct<TLogger, TEventPublisherServiceName, TEventPublisher, OutSchema, TServices, TAuditStorageServiceName, TAuditStorage> {
   readonly fn: Fn;
   input?: TInput | undefined;
-  databaseService?: Service<TDatabaseServiceName, TDatabase> | undefined;
+  databaseService?: Service<TDatabaseServiceName, TDatabase>;
   __IS_FUNCTION__: boolean;
   static isFunction(obj: any): obj is Function<any, any, any, any, any>;
   /**
@@ -25,7 +20,7 @@ declare class Function<TInput extends ComposableStandardSchema | undefined = und
    * @param data - The data to validate
    * @returns Validation result with value or issues
    */
-  static validate<T extends StandardSchemaV1>(schema: T, data: unknown): StandardSchemaV1.Result<unknown> | Promise<StandardSchemaV1.Result<unknown>>;
+  static validate<T extends StandardSchemaV1>(schema: T, data: unknown): Promise<StandardSchemaV1.Result<unknown>> | StandardSchemaV1.Result<unknown>;
   /**
    * Parses and validates data against a schema, throwing an error if validation fails.
    *
@@ -43,9 +38,8 @@ declare class Function<TInput extends ComposableStandardSchema | undefined = und
    * @throws {UnprocessableEntityError} When output validation fails
    */
   parseOutput(output: unknown): Promise<InferStandardSchema<OutSchema>>;
-  constructor(fn: Fn, timeout?: number,
-  // Default timeout of 30 seconds
-  type?: ConstructType, input?: TInput | undefined, outputSchema?: OutSchema, services?: TServices, logger?: TLogger, publisherService?: Service<TEventPublisherServiceName, TEventPublisher>, events?: MappedEvent<TEventPublisher, OutSchema>[], memorySize?: number, auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>, databaseService?: Service<TDatabaseServiceName, TDatabase> | undefined,
+  constructor(fn: Fn, timeout?: number // Default timeout of 30 seconds
+  , type?: ConstructType, input?: TInput | undefined, outputSchema?: OutSchema, services?: TServices, logger?: TLogger, publisherService?: Service<TEventPublisherServiceName, TEventPublisher>, events?: MappedEvent<TEventPublisher, OutSchema>[], memorySize?: number, auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>, databaseService?: Service<TDatabaseServiceName, TDatabase>,
   /**
    * The construct ids `.dependsOn()` named — last, so no existing positional
    * argument moves.
@@ -99,6 +93,14 @@ declare abstract class BaseFunctionBuilder<TInput extends ComposableStandardSche
    * 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;
   protected _events: MappedEvent<TEventPublisher, OutSchema>[];
   protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
   protected _auditorStorage?: Service<TAuditStorageServiceName, TAuditStorage>;
@@ -120,7 +122,6 @@ declare abstract class BaseFunctionBuilder<TInput extends ComposableStandardSche
    */
   database<T, TName extends string>(source: Consumable<TName, T> | Service<TName, T>): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, T, TName>;
 }
-//# sourceMappingURL=BaseFunctionBuilder.d.ts.map
 //#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, TEventPublisher extends EventPublisher<any> | undefined = undefined, TEventPublisherServiceName extends string = string, 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, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName> {
@@ -159,12 +160,6 @@ declare class FunctionBuilder<TInput extends ComposableStandardSchema, OutSchema
   database<T, TName extends string>(source: Consumable<TName, T> | Service<TName, T>): FunctionBuilder<TInput, OutSchema, TServices, TLogger, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, T, TName, TAuditAction>;
   handle(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase, TAuditStorage, TAuditAction>): Function<TInput, TServices, TLogger, OutSchema, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase, TAuditStorage, TAuditAction>>;
 }
-//# sourceMappingURL=FunctionBuilder.d.ts.map
-//#endregion
-//#region src/functions/index.d.ts
-declare const f: FunctionBuilder<_geekmidas_schema21.ComposableStandardSchema, undefined, [], _geekmidas_logger22.Logger, undefined, string, undefined, string, undefined, string, _geekmidas_audit23.AuditableAction<string, unknown>>;
-//# sourceMappingURL=index.d.ts.map
-
 //#endregion
-export { BaseFunctionBuilder, Function, FunctionBuilder, FunctionContext, FunctionHandler, f };
-//# sourceMappingURL=index-CubPzHd9.d.mts.map
+export { FunctionHandler as a, FunctionContext as i, BaseFunctionBuilder as n, Function as r, FunctionBuilder as t };
+//# sourceMappingURL=index-yb3fXNyH.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-yb3fXNyH.d.mts","names":[],"sources":["../src/functions/Function.ts","../src/functions/BaseFunctionBuilder.ts","../src/functions/FunctionBuilder.ts"],"mappings":"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Cf,QAAQ,IACN,gBACF,GACA,WACA,WACA,SACA,iBACA,4BACA,eACA,0BACA,WACA,sBACA;;;;;;;;;;;;EA8BD,gBAAgB,mBAAmB,cAClC,YAAY,IACV,gBACF,QACA,eACI,cAAc,WAAW,KAC7B,SACA,iBACA,4BACA,eACA,0BACA,WACA,sBACA;EAgCD,SAAS,UAAU,WAClB,UAAU,IACR,gBACF,QACA,eACI,cAAc,IAClB,SACA,iBACA,4BACA,eACA,0BACA,WACA,sBACA;EAsBD,OAAO,UAAU,QAChB,QAAQ,IACN,gBACF,QACA,WACA,WACA,GACA,iBACA,4BACA,eACA,0BACA,WACA,sBACA;EAmBQ,UAAU,UAAU,qBAAqB,sBACjD,WAAW,QAAQ,OAAO,KACxB,gBACF,QACA,WACA,WACA,SACA,GACA,OACA,eACA,0BACA,WACA,sBACA;EAwBQ,QAAQ,UAAU,cAAc,sBACxC,SAAS,QAAQ,OAAO,KACtB,gBACF,QACA,WACA,WACA,SACA,iBACA,4BACA,GACA,OACA,WACA,sBACA;;;;;EA0BD,QAAQ,UAAU,qCAAqC,gBACtD,QACA,WACA,WACA,SACA,iBACA,4BACA,eACA,0BACA,WACA,sBACA;;;;;EAqBQ,SAAS,GAAG,sBACpB,QAAQ,WAAW,OAAO,KAAK,QAAQ,OAAO,KAC5C,gBACF,QACA,WACA,WACA,SACA,iBACA,4BACA,eACA,0BACA,GACA,OACA;EA4BD,OACC,IAAI,gBACH,QACA,WACA,SACA,WACA,WACA,eACA,gBAEC,SACF,QACA,WACA,SACA,WACA,iBACA,4BACA,eACA,0BACA,WACA,sBACA,cACA,gBACC,QACA,WACA,SACA,WACA,WACA,eACA"}

package/dist/index.cjs

@@ -1,6 +1,6 @@
-const require_Construct = require('./Construct-CyS3RpTL.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_Construct = require("./Construct-yG9Sw-5p.cjs");
 exports.Construct = require_Construct.Construct;
 exports.ConstructType = require_Construct.ConstructType;
 exports.sniffService = require_Construct.sniffService;
-exports.snifferContext = require_Construct.snifferContext;
+exports.snifferContext = require_Construct.snifferContext;

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-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-DTqYvkPG.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 "./telemetry-DGcFlVpB.cjs";
 import { Service, ServiceRecord } from "@geekmidas/services";
-export { Construct, ConstructType, HttpMethod, LowerHttpMethod, RemoveUndefined, Service, ServiceRecord, Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse, sniffService, snifferContext };
+export { Construct, ConstructType, type HttpMethod, type LowerHttpMethod, type RemoveUndefined, type Service, type ServiceRecord, type Telemetry, type TelemetryContext, type TelemetryRequest, type TelemetryResponse, sniffService, snifferContext };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-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-pVadmURD.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 "./telemetry-DGcFlVpB.mjs";
 import { Service, ServiceRecord } from "@geekmidas/services";
-export { Construct, ConstructType, HttpMethod, LowerHttpMethod, RemoveUndefined, Service, ServiceRecord, Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse, sniffService, snifferContext };
+export { Construct, ConstructType, type HttpMethod, type LowerHttpMethod, type RemoveUndefined, type Service, type ServiceRecord, type Telemetry, type TelemetryContext, type TelemetryRequest, type TelemetryResponse, sniffService, snifferContext };

package/dist/index.mjs

@@ -1,3 +1,2 @@
-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-Detz65RA.mjs";
+export { Construct, ConstructType, sniffService, snifferContext };

package/dist/kysely-CEVXacPN.d.cts

@@ -0,0 +1,159 @@
+import { n as Construct } from "./construct-interface-DPusCUSQ.cjs";
+import { t as Cache } from "./cache-CYe2Kzjc.cjs";
+import { Service } from "@geekmidas/services";
+import { ConstructName, Declaration, PostgresVersion } from "@geekmidas/manifest";
+import { Kysely, KyselyConfig } from "kysely";
+//#region src/database/kysely.d.ts
+/**
+ * Everything Kysely takes, plus what this construct declares.
+ *
+ * `dialect` is omitted because the construct owns it — it is built from the one
+ * URL the adapter supplied, which is the whole point of the construct. The rest
+ * of `KyselyConfig` (`plugins`, `log`) is the app's business and passes
+ * straight through, so anything Kysely adds later arrives without being
+ * tracked here.
+ */
+interface KyselyDatabaseOptions extends Omit<KyselyConfig, 'dialect'> {
+  /**
+   * The schema, pinned on both roles' `search_path`.
+   *
+   * Defaults to `app` — the role the schema plays, rather than a restatement
+   * of the database's own name, which reads correctly beside `auth` and
+   * `pgboss` and keeps the application off `public`.
+   */
+  schema?: string;
+  /**
+   * Provision the owner/runtime role split. Defaults to on.
+   *
+   * Off falls back to the cluster's master credential in both URLs, giving up
+   * the DDL/DML split and putting credentials that can drop a table into the
+   * function's environment. A deliberate downgrade, not a default.
+   */
+  roles?: boolean;
+  /**
+   * The Postgres major version to provision.
+   *
+   * Declared here so one statement reaches both targets. It was previously
+   * set in two unrelated places — a container tag locally, nothing at all on
+   * AWS (so Aurora chose) — which is how local came to run 18 while deployed
+   * ran 17.7 with nothing recording the difference.
+   *
+   * Defaults to {@link DEFAULT_POSTGRES_VERSION}.
+   */
+  version?: PostgresVersion;
+}
+/** What makes a construct derived rather than a database in its own right. */
+interface DerivedFrom {
+  kind: 'database-reader' | 'database-schema';
+  of: string;
+  schema?: string;
+}
+/**
+ * @typeParam DB - the database's schema.
+ * @typeParam TName - the canonical id. TypeScript has no partial
+ * type-argument inference, so `new KyselyDatabase<OrdersDB>('orders')` leaves
+ * this at its default and the service key widens to `string`. `db` still types
+ * through `.database()`, which infers from the service.
+ */
+declare class KyselyDatabase<DB = unknown, TName extends string = string> implements Construct<TName, Kysely<DB>> {
+  private readonly options;
+  readonly id: TName;
+  readonly service: Service<Uncapitalize<TName>, Kysely<DB>>;
+  /**
+   * Declared once and read by both `declare()` and `connect()`, so the key the
+   * build publishes and the key the client reads cannot drift.
+   */
+  private readonly config;
+  private readonly schemaName;
+  private readonly roles;
+  private readonly version;
+  private readonly derivedFrom?;
+  constructor(id: ConstructName<TName>, options?: KyselyDatabaseOptions, derivedFrom?: DerivedFrom);
+  declare(): Declaration[];
+  /**
+   * A read-only endpoint on this database.
+   *
+   * Read-only is enforced by the reader role's grants rather than by which
+   * endpoint it resolves to, so falling back to the writer where no replica
+   * exists is safe rather than a silently writable connection behind a name
+   * that says reader. There is no `writer()`: the database *is* the writer, so
+   * a replica can never be reached by accident.
+   *
+   * The return type is narrower than this class on purpose — see
+   * {@link ReadOnlyDatabase}.
+   */
+  reader(): ReadOnlyDatabase<DB, `${TName}Reader`>;
+  /**
+   * A cache that lives in this database.
+   *
+   * The same strengthening `schema()` is over a second database: `new
+   * Cache('Sessions')` says the app caches and leaves where to the deployment,
+   * while this says it caches *here* — which is a fact about the application
+   * and so belongs in its code.
+   *
+   * What it buys beyond being explicit: the table's schema and the role that
+   * reaches it come from this database rather than from a second convention,
+   * and the backend no longer has to guess which database "the database" meant
+   * when an app declares two.
+   *
+   * A cache is not a `KyselyDatabase`, so this returns a `Cache` — the client
+   * is a key/value store, not a query builder, and typing it as the parent
+   * would be a convenience that lies.
+   */
+  cache<TCache extends string = `${TName}Cache`>(id?: ConstructName<TCache>, options?: {
+    table?: string;
+  }): Cache<TCache>;
+  /**
+   * A second schema in this database, with its own role(s) and its own URL —
+   * so this database's role holds no grant on those tables at all.
+   *
+   * Typed separately because a tenant has its own tables: the point is that
+   * `auth.selectFrom('sessions')` type-checks and
+   * `orders.selectFrom('sessions')` does not.
+   */
+  schema<TenantDB, TTenant extends string>(id: ConstructName<TTenant>, options?: KyselyDatabaseOptions): KyselyDatabase<TenantDB, TTenant>;
+  /**
+   * A connection as the *owner* role — the one that may create, alter and drop.
+   *
+   * A `Service` rather than part of the construct, and deliberately so: a
+   * construct is what `.dependsOn()` accepts, and nothing should be able to
+   * depend on this. A migrator asks for it by name; a handler cannot ask at
+   * all, which is the security property the role split exists for.
+   *
+   * Falls back to the runtime URL where no owner URL was published — the
+   * `roles: false` downgrade, where there is only one credential and it is the
+   * cluster master's.
+   */
+  get owner(): Service<`${Uncapitalize<TName>}Owner`, Kysely<DB>>;
+  /**
+   * What this database's clients are built with besides a dialect — the
+   * plugins and logging it was declared with.
+   *
+   * Public so that whatever opens a connection to it outside \`connect()\` —
+   * a test's transaction — builds the same client. A test that dropped the
+   * plugins would write \`createdAt\` where production writes \`created_at\`.
+   */
+  get clientConfig(): Omit<KyselyConfig, 'dialect'>;
+  private connect;
+}
+/**
+ * A database you may read through, and derive nothing from.
+ *
+ * A reader is terminal in the graph, and this is that fact in the type system.
+ * `DERIVES_FROM` gives `cache` and `database-schema` no `database-reader`
+ * parent, and there is no reader of a reader — so `orders.reader().cache(…)`
+ * has always been illegal, but it type-checked and failed later at
+ * `assertDerivations`. That is a long way round to learn that a read-only
+ * endpoint cannot own a table something writes to.
+ *
+ * Omitting the three deriving methods rather than making them throw keeps the
+ * failure where it costs least: the editor, on the line that wrote it.
+ *
+ * The result is deliberately not assignable back to `KyselyDatabase` — a
+ * reader is not one, and anything that genuinely needs the writer should say
+ * so.
+ */
+type ReadOnlyDatabase<DB, TName extends string> = Omit<KyselyDatabase<DB, TName>, 'reader' | 'cache' | 'schema'>;
+//#endregion
+export { KyselyDatabaseOptions as n, ReadOnlyDatabase as r, KyselyDatabase as t };
+//# sourceMappingURL=kysely-CEVXacPN.d.cts.map

package/dist/kysely-CEVXacPN.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-CEVXacPN.d.cts","names":[],"sources":["../src/database/kysely.ts"],"mappings":";;;;;;;;;;;;;;;UAwCiB,8BAA8B,KAAK;;;;;;;;EAQnD;;;;;;;;EAQA;;;;;;;;;;;EAWA,UAAU;;;UAID;EACT;EACA;EACA;;;;;;;;;cAUY,eAAe,cAAc,0CAC9B,UAAU,OAAO,OAAO;mBAiBjB;WAfT,IAAI;WACJ,SAAS,QAAQ,aAAa,QAAQ,OAAO;;;;;mBAMrC;mBACA;mBACA;mBACA;mBACA;EAEjB,YACC,IAAI,cAAc,QACD,UAAS,uBAC1B,cAAc;EAyBf,WAAW;;;;;;;;;;;;;EAqDX,UAAU,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;EAyBlC,MAAM,2BAA2B,cAChC,KAAI,cAAc,SAClB;IAAW;MACT,MAAM;;;;;;;;;EAeT,OAAO,UAAU,wBAChB,IAAI,cAAc,UAClB,UAAS,wBACP,eAAe,UAAU;;;;;;;;;;;;;MAoBxB,SAAS,WAAW,aAAa,eAAe,OAAO;;;;;;;;;MAgBvD,gBAAgB,KAAK;UAaX;;;;;;;;;;;;;;;;;;;KA6DH,iBAAiB,IAAI,wBAAwB,KACxD,eAAe,IAAI"}

package/dist/kysely-mcTdPNhl.d.mts

@@ -0,0 +1,159 @@
+import { n as Construct } from "./construct-interface-D2gesxos.mjs";
+import { t as Cache } from "./cache-B2s0b-ss.mjs";
+import { ConstructName, Declaration, PostgresVersion } from "@geekmidas/manifest";
+import { Kysely, KyselyConfig } from "kysely";
+import { Service } from "@geekmidas/services";
+//#region src/database/kysely.d.ts
+/**
+ * Everything Kysely takes, plus what this construct declares.
+ *
+ * `dialect` is omitted because the construct owns it — it is built from the one
+ * URL the adapter supplied, which is the whole point of the construct. The rest
+ * of `KyselyConfig` (`plugins`, `log`) is the app's business and passes
+ * straight through, so anything Kysely adds later arrives without being
+ * tracked here.
+ */
+interface KyselyDatabaseOptions extends Omit<KyselyConfig, 'dialect'> {
+  /**
+   * The schema, pinned on both roles' `search_path`.
+   *
+   * Defaults to `app` — the role the schema plays, rather than a restatement
+   * of the database's own name, which reads correctly beside `auth` and
+   * `pgboss` and keeps the application off `public`.
+   */
+  schema?: string;
+  /**
+   * Provision the owner/runtime role split. Defaults to on.
+   *
+   * Off falls back to the cluster's master credential in both URLs, giving up
+   * the DDL/DML split and putting credentials that can drop a table into the
+   * function's environment. A deliberate downgrade, not a default.
+   */
+  roles?: boolean;
+  /**
+   * The Postgres major version to provision.
+   *
+   * Declared here so one statement reaches both targets. It was previously
+   * set in two unrelated places — a container tag locally, nothing at all on
+   * AWS (so Aurora chose) — which is how local came to run 18 while deployed
+   * ran 17.7 with nothing recording the difference.
+   *
+   * Defaults to {@link DEFAULT_POSTGRES_VERSION}.
+   */
+  version?: PostgresVersion;
+}
+/** What makes a construct derived rather than a database in its own right. */
+interface DerivedFrom {
+  kind: 'database-reader' | 'database-schema';
+  of: string;
+  schema?: string;
+}
+/**
+ * @typeParam DB - the database's schema.
+ * @typeParam TName - the canonical id. TypeScript has no partial
+ * type-argument inference, so `new KyselyDatabase<OrdersDB>('orders')` leaves
+ * this at its default and the service key widens to `string`. `db` still types
+ * through `.database()`, which infers from the service.
+ */
+declare class KyselyDatabase<DB = unknown, TName extends string = string> implements Construct<TName, Kysely<DB>> {
+  private readonly options;
+  readonly id: TName;
+  readonly service: Service<Uncapitalize<TName>, Kysely<DB>>;
+  /**
+   * Declared once and read by both `declare()` and `connect()`, so the key the
+   * build publishes and the key the client reads cannot drift.
+   */
+  private readonly config;
+  private readonly schemaName;
+  private readonly roles;
+  private readonly version;
+  private readonly derivedFrom?;
+  constructor(id: ConstructName<TName>, options?: KyselyDatabaseOptions, derivedFrom?: DerivedFrom);
+  declare(): Declaration[];
+  /**
+   * A read-only endpoint on this database.
+   *
+   * Read-only is enforced by the reader role's grants rather than by which
+   * endpoint it resolves to, so falling back to the writer where no replica
+   * exists is safe rather than a silently writable connection behind a name
+   * that says reader. There is no `writer()`: the database *is* the writer, so
+   * a replica can never be reached by accident.
+   *
+   * The return type is narrower than this class on purpose — see
+   * {@link ReadOnlyDatabase}.
+   */
+  reader(): ReadOnlyDatabase<DB, `${TName}Reader`>;
+  /**
+   * A cache that lives in this database.
+   *
+   * The same strengthening `schema()` is over a second database: `new
+   * Cache('Sessions')` says the app caches and leaves where to the deployment,
+   * while this says it caches *here* — which is a fact about the application
+   * and so belongs in its code.
+   *
+   * What it buys beyond being explicit: the table's schema and the role that
+   * reaches it come from this database rather than from a second convention,
+   * and the backend no longer has to guess which database "the database" meant
+   * when an app declares two.
+   *
+   * A cache is not a `KyselyDatabase`, so this returns a `Cache` — the client
+   * is a key/value store, not a query builder, and typing it as the parent
+   * would be a convenience that lies.
+   */
+  cache<TCache extends string = `${TName}Cache`>(id?: ConstructName<TCache>, options?: {
+    table?: string;
+  }): Cache<TCache>;
+  /**
+   * A second schema in this database, with its own role(s) and its own URL —
+   * so this database's role holds no grant on those tables at all.
+   *
+   * Typed separately because a tenant has its own tables: the point is that
+   * `auth.selectFrom('sessions')` type-checks and
+   * `orders.selectFrom('sessions')` does not.
+   */
+  schema<TenantDB, TTenant extends string>(id: ConstructName<TTenant>, options?: KyselyDatabaseOptions): KyselyDatabase<TenantDB, TTenant>;
+  /**
+   * A connection as the *owner* role — the one that may create, alter and drop.
+   *
+   * A `Service` rather than part of the construct, and deliberately so: a
+   * construct is what `.dependsOn()` accepts, and nothing should be able to
+   * depend on this. A migrator asks for it by name; a handler cannot ask at
+   * all, which is the security property the role split exists for.
+   *
+   * Falls back to the runtime URL where no owner URL was published — the
+   * `roles: false` downgrade, where there is only one credential and it is the
+   * cluster master's.
+   */
+  get owner(): Service<`${Uncapitalize<TName>}Owner`, Kysely<DB>>;
+  /**
+   * What this database's clients are built with besides a dialect — the
+   * plugins and logging it was declared with.
+   *
+   * Public so that whatever opens a connection to it outside \`connect()\` —
+   * a test's transaction — builds the same client. A test that dropped the
+   * plugins would write \`createdAt\` where production writes \`created_at\`.
+   */
+  get clientConfig(): Omit<KyselyConfig, 'dialect'>;
+  private connect;
+}
+/**
+ * A database you may read through, and derive nothing from.
+ *
+ * A reader is terminal in the graph, and this is that fact in the type system.
+ * `DERIVES_FROM` gives `cache` and `database-schema` no `database-reader`
+ * parent, and there is no reader of a reader — so `orders.reader().cache(…)`
+ * has always been illegal, but it type-checked and failed later at
+ * `assertDerivations`. That is a long way round to learn that a read-only
+ * endpoint cannot own a table something writes to.
+ *
+ * Omitting the three deriving methods rather than making them throw keeps the
+ * failure where it costs least: the editor, on the line that wrote it.
+ *
+ * The result is deliberately not assignable back to `KyselyDatabase` — a
+ * reader is not one, and anything that genuinely needs the writer should say
+ * so.
+ */
+type ReadOnlyDatabase<DB, TName extends string> = Omit<KyselyDatabase<DB, TName>, 'reader' | 'cache' | 'schema'>;
+//#endregion
+export { KyselyDatabaseOptions as n, ReadOnlyDatabase as r, KyselyDatabase as t };
+//# sourceMappingURL=kysely-mcTdPNhl.d.mts.map

package/dist/kysely-mcTdPNhl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-mcTdPNhl.d.mts","names":[],"sources":["../src/database/kysely.ts"],"mappings":";;;;;;;;;;;;;;;UAwCiB,8BAA8B,KAAK;;;;;;;;EAQnD;;;;;;;;EAQA;;;;;;;;;;;EAWA,UAAU;;;UAID;EACT;EACA;EACA;;;;;;;;;cAUY,eAAe,cAAc,0CAC9B,UAAU,OAAO,OAAO;mBAiBjB;WAfT,IAAI;WACJ,SAAS,QAAQ,aAAa,QAAQ,OAAO;;;;;mBAMrC;mBACA;mBACA;mBACA;mBACA;EAEjB,YACC,IAAI,cAAc,QACD,UAAS,uBAC1B,cAAc;EAyBf,WAAW;;;;;;;;;;;;;EAqDX,UAAU,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;EAyBlC,MAAM,2BAA2B,cAChC,KAAI,cAAc,SAClB;IAAW;MACT,MAAM;;;;;;;;;EAeT,OAAO,UAAU,wBAChB,IAAI,cAAc,UAClB,UAAS,wBACP,eAAe,UAAU;;;;;;;;;;;;;MAoBxB,SAAS,WAAW,aAAa,eAAe,OAAO;;;;;;;;;MAgBvD,gBAAgB,KAAK;UAaX;;;;;;;;;;;;;;;;;;;KA6DH,iBAAiB,IAAI,wBAAwB,KACxD,eAAe,IAAI"}