@geekmidas/constructs 10.0.0-alpha.4 → 10.0.0-alpha.40

package/dist/Construct-QXnl3VqT.d.mts

@@ -0,0 +1,230 @@
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
+import { SniffResult } from "@geekmidas/envkit/sniffer";
+import { ConstructName, Declaration } from "@geekmidas/manifest";
+import { EventPublisher, PublishableMessage } from "@geekmidas/events";
+import { Service, ServiceContext, ServiceDiscovery } from "@geekmidas/services";
+import { AuditStorage } from "@geekmidas/audit";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+//#region src/topic/Topic.d.ts
+/** A topic's event contract — a map of event type → payload schema. */
+type TopicEvents = Record<string, StandardSchemaV1>;
+/**
+ * The union of wire messages a topic carries, derived from its event map:
+ * `{ type: 'user.created'; payload: … } | { type: 'user.updated'; payload: … }`.
+ */
+type TopicMessage<TEvents extends TopicEvents> = { [K in keyof TEvents & string]: PublishableMessage<K, InferStandardSchema<TEvents[K]>>; }[keyof TEvents & string];
+/**
+ * A topic — pub/sub fan-out. Unlike a `Queue` (point-to-point, one consumer), a
+ * topic is a *resource* owned by no single handler: it declares the event
+ * contract, and any number of subscribers (`worker.topic(topic)`) bind to it.
+ * `gkm build` discovers it into the manifest's `topics` field; infra provisions
+ * an SNS topic.
+ *
+ * A construct publishes with `.event(topic, { type, payload })`, repeatable
+ * across topics, each event going through its own topic's publisher. That also
+ * puts `services.<topic>` in the handler, as `.dependsOn([topic])` does, for an
+ * event the handler decides on itself.
+ *
+ * ```ts
+ * export const users = new Topic('Users', {
+ *   events: { 'user.created': z.object({ userId: z.string() }) },
+ * });
+ * ```
+ */
+declare class Topic<TName extends string = string, TEvents extends TopicEvents = TopicEvents> extends Construct {
+  __IS_TOPIC__: boolean;
+  static isTopic(obj: unknown): obj is Topic<string, TopicEvents>;
+  /**
+   * The canonical id this topic is declared under.
+   *
+   * Derived from the name, so `users` and `Users` are one topic. The name is
+   * left alone: subscribers bind to it and it is what the broker routes on.
+   */
+  readonly id: string;
+  /** The name it was declared with — what the broker routes on. */
+  readonly name: TName;
+  /**
+   * The event contract — a map of event type → payload schema. Named
+   * `eventSchemas` (not `events`) to avoid clashing with `Construct.events`,
+   * which is the array of `MappedEvent`s a construct *publishes*.
+   */
+  readonly eventSchemas: TEvents;
+  /**
+   * The topic as a dependency — what `.dependsOn([users])` and
+   * `.event(users, …)` dissolve into, reachable as `services.users`.
+   *
+   * The producer, because publishing is the only thing depending on a topic
+   * can mean: a subscriber binds to the topic instead, and is never handed
+   * this. It reads `<NAME>_PUBLISHER_CONNECTION_STRING` and picks the
+   * transport from its protocol — `pgboss://` locally, `sns://` deployed.
+   *
+   * A field assigned once, not a getter: services are cached by object
+   * identity, and a fresh literal on every access never hit that cache.
+   */
+  readonly service: Service<Uncapitalize<TName>, EventPublisher<TopicMessage<TEvents>>>;
+  /** The producer's env key, read by both {@link declare} and the service. */
+  private readonly connectionKey;
+  constructor(name: ConstructName<TName>, options: TopicOptions<TEvents>);
+  /**
+   * What this topic is in the manifest.
+   *
+   * Only the producer's key: a subscriber is *bound* to a topic rather than
+   * depending on it, so the binding is an edge the deploy target reads and not
+   * an env key anyone can hold. Locally both sides meet on the same broker.
+   */
+  declare(): Declaration[];
+  /** The event type names this topic carries. */
+  get eventTypes(): (keyof TEvents & string)[];
+}
+interface TopicOptions<TEvents extends TopicEvents> {
+  /** Each event this topic carries — its type, and its payload's schema. */
+  events: TEvents;
+}
+//#endregion
+//#region src/publisher.d.ts
+/**
+ * An event a construct publishes to a topic once its handler has succeeded.
+ *
+ * It carries its topic, so a construct can publish to as many topics as it
+ * names — each event goes through the publisher of the topic it was declared
+ * against, never a single shared one.
+ */
+interface TopicEvent<TOutput = any> {
+  /** The topic's service: the publisher this event is sent through. */
+  topic: Service<string, EventPublisher<any>>;
+  type: string;
+  /** The event's payload, from what the handler returned. */
+  payload: (output: TOutput) => unknown;
+  /** Publish only when this holds for what the handler returned. */
+  when?: (output: TOutput) => boolean;
+}
+/**
+ * What `.event(topic, …)` takes: one of the topic's event types, and a payload
+ * of that event's shape built from the handler's output.
+ */
+type EventFor<TTopic extends Topic<any, any>, TOutput> = TTopic extends Topic<string, infer TEvents> ? { [K in keyof TEvents & string]: {
+  type: K;
+  payload: (output: TOutput) => InferStandardSchema<TEvents[K]>;
+  when?: (output: TOutput) => boolean;
+}; }[keyof TEvents & string] : never;
+/** Publish a construct's declared events for what its handler returned. */
+declare function publishConstructEvents<OutSchema extends StandardSchemaV1 | undefined = undefined>(construct: Pick<Construct, 'events' | 'logger'>, response: InferStandardSchema<OutSchema>, serviceDiscovery: ServiceDiscovery<any>, logger?: Logger, provided?: Readonly<Record<string, unknown>>): Promise<void>;
+//#endregion
+//#region src/Construct.d.ts
+/**
+ * Noop context for environment sniffing.
+ * Used when calling service.register() to detect env vars without a real request.
+ * Returns dummy values since services should only use context in instance methods,
+ * not during registration.
+ */
+declare const snifferContext: ServiceContext;
+declare abstract class Construct<TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TAuditStorageServiceName extends string = string, TAuditStorage extends AuditStorage | undefined = undefined, TDatabaseServiceName extends string = string, TDatabase = unknown> {
+  readonly type: ConstructType;
+  readonly logger: TLogger;
+  readonly services: TServices;
+  /**
+   * What this construct publishes once its handler succeeds — each event
+   * bound to its own topic, so a construct publishes to as many as it names.
+   */
+  readonly events: TopicEvent[];
+  outputSchema?: OutSchema | undefined;
+  readonly timeout?: number | undefined;
+  readonly memorySize?: number | undefined;
+  readonly auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>;
+  /**
+   * The constructs this one declared an edge to, by id.
+   *
+   * What the manifest records. `services` is the same information in the
+   * form a handler runs with — clients, keyed by name — and an id cannot be
+   * recovered from one of those reliably, so both are kept.
+   *
+   * Last in the list because every other parameter is positional and already
+   * spoken for; a new one anywhere else silently rebinds existing callers.
+   */
+  readonly constructs: string[];
+  /** Database service for this construct (used by Endpoint for RLS/audit context) */
+  databaseService?: Service<TDatabaseServiceName, TDatabase>;
+  /**
+   * The deploy unit that runs this, by construct id.
+   *
+   * What an endpoint's `surface` is to it, and for the same reason: something
+   * has to say which process a runnable belongs to, and until this existed the
+   * only thing that said so was the directory its file sat in. Set by the
+   * factory it was built from — `worker.crons`, `api.get(…)` — so it is
+   * carried rather than configured.
+   *
+   * Undefined for a construct built from a free-standing builder, which is
+   * still how `c`, `s` and `f` work.
+   */
+  owner?: string;
+  constructor(type: ConstructType, logger: TLogger, services: TServices,
+  /**
+   * What this construct publishes once its handler succeeds — each event
+   * bound to its own topic, so a construct publishes to as many as it names.
+   */
+  events?: TopicEvent[], outputSchema?: OutSchema | undefined, timeout?: number | undefined, memorySize?: number | undefined, auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>,
+  /**
+   * The constructs this one declared an edge to, by id.
+   *
+   * What the manifest records. `services` is the same information in the
+   * form a handler runs with — clients, keyed by name — and an id cannot be
+   * recovered from one of those reliably, so both are kept.
+   *
+   * Last in the list because every other parameter is positional and already
+   * spoken for; a new one anywhere else silently rebinds existing callers.
+   */
+  constructs?: string[]);
+  /**
+   * 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.
+   *
+   * Results are cached per service class to handle singleton patterns where
+   * subsequent register() calls may short-circuit and not access env vars.
+   *
+   * @param markOptional - When true, optional vars (those accessed via `.optional()` or
+   *   `.default()`) are suffixed with `?` in the returned array (e.g. `'PORT?'`).
+   * @returns Promise that resolves to array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const endpoint = e
+   *   .services([databaseService, authService])
+   *   .get('/users')
+   *   .handle(async () => []);
+   *
+   * await endpoint.getEnvironment();               // ['AUTH_SECRET', 'DATABASE_URL']
+   * await endpoint.getEnvironment({ markOptional: true }); // ['AUTH_SECRET', 'DATABASE_URL', 'PORT?']
+   * ```
+   */
+  getEnvironment(opts?: {
+    markOptional?: boolean;
+  }): 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",
+  Queue = "dev.geekmidas.function.queue",
+  Topic = "dev.geekmidas.resource.topic"
+}
+/**
+ * Utility to test sniffing a service for environment variables.
+ * Useful for debugging services that throw errors during sniffing.
+ *
+ * @example
+ * ```typescript
+ * import { sniffService } from '@geekmidas/constructs';
+ * import { authService } from './services/AuthService';
+ *
+ * const result = await sniffService(authService);
+ * console.log('Env vars:', result.envVars);
+ * console.log('Error:', result.error);
+ * ```
+ */
+declare function sniffService(service: Service): Promise<SniffResult>;
+//#endregion
+export { EventFor as a, Topic as c, TopicOptions as d, snifferContext as i, TopicEvents as l, ConstructType as n, TopicEvent as o, sniffService as r, publishConstructEvents as s, Construct as t, TopicMessage as u };
+//# sourceMappingURL=Construct-QXnl3VqT.d.mts.map

package/dist/Construct-QXnl3VqT.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct-QXnl3VqT.d.mts","names":[],"sources":["../src/topic/Topic.ts","../src/publisher.ts","../src/Construct.ts"],"mappings":";;;;;;;;;;KAoBY,cAAc,eAAe;;;;;KAM7B,aAAa,gBAAgB,kBACvC,WAAW,mBAAmB,mBAC9B,GACA,oBAAoB,QAAQ,cAEtB;;;;;;;;;;;;;;;;;;;cAoBK,MACZ,+BACA,gBAAgB,cAAc,qBACrB;EACT;SAEO,QAAQ,eAAe,OAAO,cAAc;;;;;;;WAc1C;;WAGA,MAAM;;;;;;WAON,cAAc;;;;;;;;;;;;;WAcd,SAAS,QACjB,aAAa,QACb,eAAe,aAAa;;mBAIZ;EAEjB,YAAY,MAAM,cAAc,QAAQ,SAAS,aAAa;;;;;;;;EAkC9D,WAAW;;MAmBP,qBAAqB;;UAKT,aAAa,gBAAgB;;EAE7C,QAAQ;;;;;;;;;;;UCpJQ,WAAW;;EAE3B,OAAO,gBAAgB;EACvB;;EAEA,UAAU,QAAQ;;EAElB,QAAQ,QAAQ;;;;;;KAOL,SACX,eAAe,iBACf,WACG,eAAe,oBAAoB,cAEnC,WAAW;EACX,MAAM;EACN,UAAU,QAAQ,YAAY,oBAAoB,QAAQ;EAC1D,QAAQ,QAAQ;WAEV;;iBAwFY,uBACrB,kBAAkB,0CAElB,WAAW,KAAK,iCAChB,UAAU,oBAAoB,YAC9B,kBAAkB,uBAClB,SAAQ,QACR,WAAU,SAAS,2BAA6B;;;;;;;;;cC5G3C,gBAAgB;uBAsBA,UACrB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,kBAAkB,gBAClB,kDACA,sBAAsB,sCACtB,8CACA;WAoBiB,MAAM;WACN,QAAQ;WACR,UAAU;;;;;WAKV,QAAQ;EACjB,eAAe;WACN;WACA;WACA,wBAAwB,QACvC,0BACA;;;;;;;;;;;WAYe;;EA1CV,kBAAkB,QAAQ,sBAAsB;;;;;;;;;;;;;EAchD;EAEP,YACiB,MAAM,eACN,QAAQ,SACR,UAAU,WAKV;;;;;EAAA,SAAQ,cACjB,eAAe,uBACN,8BACA,iCACA,wBAAwB,QACvC,0BACA,gBAYe;;;;;;;;;;;EAAA;;;;;;;;;;;;;;;;;;;;;;;;EA0BX,eACL;IAAQ;MACN;;aAiEQ;EACX;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;iBAiBqB,aAAa,SAAS,UAAU,QAAQ"}

package/dist/{Cron-B2OFsfDM.d.cts → Cron-CMEGfRs8.d.cts}

@@ -1,16 +1,29 @@
-import { Function, FunctionHandler } from "./index-AIfVzkhi.cjs";
-import { EventPublisher } from "@geekmidas/events";
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.cjs";
+import { o as TopicEvent } from "./Construct-BQALFCh2.cjs";
+import { a as FunctionHandler, r as Function } from "./index-B0kxstwf.cjs";
 import { Logger } from "@geekmidas/logger";
 import { ComposableStandardSchema } from "@geekmidas/schema";
 import { Service } from "@geekmidas/services";
-import { StandardSchemaV1 } from "@standard-schema/spec";
 import { AuditableAction } from "@geekmidas/audit";
-
 //#region src/crons/Cron.d.ts
-declare class Cron<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, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, TEventPublisher, TEventPublisherServiceName, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
+declare class Cron<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
   protected _schedule?: ScheduleExpression | undefined;
+  /**
+   * Where this cron's schedule lives when a server runs it.
+   *
+   * Carried from the worker that built it, which declared it once with
+   * `.database(db)`. Unread on AWS, where the schedule is an EventBridge rule
+   * and nothing in this process fires anything.
+   *
+   * A service rather than the construct, because what reads it is service
+   * discovery in the generated server — which registers services, and failed
+   * on the construct with `service.register is not a function`.
+   */
+  scheduleStore?: Service<string, unknown>;
   static isCron(obj: any): obj is Cron<any, any, any, any>;
-  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger, publisherService?: Service<TEventPublisherServiceName, TEventPublisher>, events?: any[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
+  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger,
+  /** What it publishes once it has run, each to its own topic. */
+  events?: TopicEvent[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
   /**
    * The construct ids `.dependsOn()` named — last, so no existing positional
    * argument moves.
@@ -27,5 +40,5 @@ type CronWeekday = '*' | number | `${number}` | `${number}-${number}` | `${numbe
 type CronExpression = `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;
 type ScheduleExpression = RateExpression | CronExpression;
 //#endregion
-export { Cron, CronExpression, RateExpression, ScheduleExpression };
-//# sourceMappingURL=Cron-B2OFsfDM.d.cts.map
+export { ScheduleExpression as i, CronExpression as n, RateExpression as r, Cron as t };
+//# sourceMappingURL=Cron-CMEGfRs8.d.cts.map

package/dist/Cron-CMEGfRs8.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron-CMEGfRs8.d.cts","names":[],"sources":["../src/crons/Cron.ts"],"mappings":";;;;;;;;cAUa,KACZ,eAAe,kDACf,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,uBACA,sDACS,SACT,QACA,WACA,SACA,8BAGA,WACA,sBACA,kCACA,gBAAgB,QAAQ,WAAW,SAAS,WAAW;YA0B5C,YAAY;;;;;;;;;;;;EAbvB,gBAAgB;SAET,OAAO,WAAW,OAAO;EAQhC,YACC,IAAI,gBAAgB,QAAQ,WAAW,SAAS,WAAW,YAC3D,kBACU,YAAY,gCACtB,QAAQ,QACR,eAAe,WACf,WAAU,WACV,SAAS,SAET;;EAAA,SAAQ,cACR,qBACA,kBAAkB,QAAQ,sBAAsB,YAKhD;;;;;EAAA;MAkBG,YAAY;;KAKL;KAEP;KAUA;KAUA;KAUA;KAqBA;KAiBO,yBACH,cAAc,YAAY,WAAW,aAAa;KAE/C,qBAAqB,iBAAiB"}

package/dist/{Cron-ByxdOfpE.d.mts → Cron-D6X4-xjB.d.mts}

@@ -1,16 +1,29 @@
-import { Function, FunctionHandler } from "./index-CubPzHd9.mjs";
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
+import { o as TopicEvent } from "./Construct-QXnl3VqT.mjs";
+import { a as FunctionHandler, r as Function } from "./index-CjVEjOw0.mjs";
 import { Service } from "@geekmidas/services";
 import { AuditableAction } from "@geekmidas/audit";
-import { EventPublisher } from "@geekmidas/events";
 import { Logger } from "@geekmidas/logger";
 import { ComposableStandardSchema } from "@geekmidas/schema";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/crons/Cron.d.ts
-declare class Cron<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, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, TEventPublisher, TEventPublisherServiceName, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
+declare class Cron<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
   protected _schedule?: ScheduleExpression | undefined;
+  /**
+   * Where this cron's schedule lives when a server runs it.
+   *
+   * Carried from the worker that built it, which declared it once with
+   * `.database(db)`. Unread on AWS, where the schedule is an EventBridge rule
+   * and nothing in this process fires anything.
+   *
+   * A service rather than the construct, because what reads it is service
+   * discovery in the generated server — which registers services, and failed
+   * on the construct with `service.register is not a function`.
+   */
+  scheduleStore?: Service<string, unknown>;
   static isCron(obj: any): obj is Cron<any, any, any, any>;
-  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger, publisherService?: Service<TEventPublisherServiceName, TEventPublisher>, events?: any[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
+  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger,
+  /** What it publishes once it has run, each to its own topic. */
+  events?: TopicEvent[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
   /**
    * The construct ids `.dependsOn()` named — last, so no existing positional
    * argument moves.
@@ -27,5 +40,5 @@ type CronWeekday = '*' | number | `${number}` | `${number}-${number}` | `${numbe
 type CronExpression = `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;
 type ScheduleExpression = RateExpression | CronExpression;
 //#endregion
-export { Cron, CronExpression, RateExpression, ScheduleExpression };
-//# sourceMappingURL=Cron-ByxdOfpE.d.mts.map
+export { ScheduleExpression as i, CronExpression as n, RateExpression as r, Cron as t };
+//# sourceMappingURL=Cron-D6X4-xjB.d.mts.map

package/dist/Cron-D6X4-xjB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron-D6X4-xjB.d.mts","names":[],"sources":["../src/crons/Cron.ts"],"mappings":";;;;;;;;cAUa,KACZ,eAAe,kDACf,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,uBACA,sDACS,SACT,QACA,WACA,SACA,8BAGA,WACA,sBACA,kCACA,gBAAgB,QAAQ,WAAW,SAAS,WAAW;YA0B5C,YAAY;;;;;;;;;;;;EAbvB,gBAAgB;SAET,OAAO,WAAW,OAAO;EAQhC,YACC,IAAI,gBAAgB,QAAQ,WAAW,SAAS,WAAW,YAC3D,kBACU,YAAY,gCACtB,QAAQ,QACR,eAAe,WACf,WAAU,WACV,SAAS,SAET;;EAAA,SAAQ,cACR,qBACA,kBAAkB,QAAQ,sBAAsB,YAKhD;;;;;EAAA;MAkBG,YAAY;;KAKL;KAEP;KAUA;KAUA;KAUA;KAqBA;KAiBO,yBACH,cAAc,YAAY,WAAW,aAAa;KAE/C,qBAAqB,iBAAiB"}

package/dist/CronBuilder-CEK7aOqD.d.cts

@@ -0,0 +1,46 @@
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.cjs";
+import { a as EventFor, c as Topic } from "./Construct-BQALFCh2.cjs";
+import { a as FunctionHandler, t as FunctionBuilder } from "./index-B0kxstwf.cjs";
+import { c as ServicesOf, r as Consumable } from "./construct-interface-_xi4BPN8.cjs";
+import { i as ScheduleExpression, t as Cron } from "./Cron-CMEGfRs8.cjs";
+import { Logger } from "@geekmidas/logger";
+import { ComposableStandardSchema, InferStandardSchema } from "@geekmidas/schema";
+import { Service } from "@geekmidas/services";
+//#region src/crons/CronBuilder.d.ts
+declare class CronBuilder<TInput extends ComposableStandardSchema, TServices extends Service[], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TDatabase = undefined, TDatabaseServiceName extends string = string> extends FunctionBuilder<TInput, OutSchema, TServices, TLogger, undefined, string, TDatabase, TDatabaseServiceName> {
+  private _schedule?;
+  constructor();
+  memorySize(memorySize: number): this;
+  schedule(_expression: ScheduleExpression): CronBuilder<TInput, TServices, TLogger, OutSchema, TDatabase, TDatabaseServiceName>;
+  input<T extends ComposableStandardSchema>(schema: T): CronBuilder<T, TServices, TLogger, OutSchema, TDatabase, TDatabaseServiceName>;
+  output<T extends StandardSchemaV1>(schema: T): CronBuilder<TInput, TServices, TLogger, T, TDatabase, TDatabaseServiceName>;
+  /**
+   * 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): CronBuilder<TInput, [...TServices, ...ServicesOf<T>], TLogger, OutSchema, TDatabase, TDatabaseServiceName>;
+  services<T extends Service[]>(services: T): CronBuilder<TInput, [...TServices, ...T], TLogger, OutSchema, TDatabase, TDatabaseServiceName>;
+  logger<T extends Logger>(logger: T): CronBuilder<TInput, TServices, T, OutSchema, TDatabase, TDatabaseServiceName>;
+  /**
+   * Publish `event` to `topic` each time the cron has run successfully —
+   * repeatable, to as many topics as it names. The topic becomes a dependency
+   * as with `.dependsOn([topic])`, so `services.<topic>` is there too.
+   */
+  event<TTopic extends Topic<any, any>>(topic: TTopic, event: EventFor<TTopic, InferStandardSchema<OutSchema>>): CronBuilder<TInput, [...TServices, TTopic['service']], TLogger, OutSchema, TDatabase, TDatabaseServiceName>;
+  /**
+   * Set the database service for this cron job.
+   * The database will be available in the handler context as `db`.
+   */
+  database<T, TName extends string>(source: Consumable<TName, T> | Service<TName, T>): CronBuilder<TInput, TServices, TLogger, OutSchema, T, TName>;
+  handle(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>): Cron<TInput, TServices, TLogger, OutSchema, TDatabase, TDatabaseServiceName>;
+}
+//#endregion
+export { CronBuilder as t };
+//# sourceMappingURL=CronBuilder-CEK7aOqD.d.cts.map

package/dist/CronBuilder-CEK7aOqD.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CronBuilder-CEK7aOqD.d.cts","names":[],"sources":["../src/crons/CronBuilder.ts"],"mappings":";;;;;;;;;cAuBa,YACZ,eAAe,0BACf,kBAAkB,WAClB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,uBACA,sDACS,gBACT,QACA,WACA,WACA,4BAGA,WACA;UAEQ;EAER;EAIS,WAAW;EAIpB,SACC,aAAa,qBACX,YACF,QACA,WACA,SACA,WACA,WACA;EAKQ,MAAM,UAAU,0BACxB,QAAQ,IACN,YACF,GACA,WACA,SACA,WACA,WACA;EAcQ,OAAO,UAAU,kBACzB,QAAQ,IACN,YACF,QACA,WACA,SACA,GACA,WACA;;;;;;;;;;;;EAyBQ,gBAAgB,mBAAmB,cAC3C,YAAY,IACV,YACF,YACI,cAAc,WAAW,KAC7B,SACA,WACA,WACA;EA2BQ,SAAS,UAAU,WAC3B,UAAU,IACR,YACF,YACI,cAAc,IAClB,SACA,WACA,WACA;EAiBQ,OAAO,UAAU,QACzB,QAAQ,IACN,YACF,QACA,WACA,GACA,WACA,WACA;;;;;;EAmBQ,MAAM,eAAe,iBAC7B,OAAO,QACP,OAAO,SAAS,QAAQ,oBAAoB,cAC1C,YACF,YACI,WAAW,oBACf,SACA,WACA,WACA;;;;;EAgBQ,SAAS,GAAG,sBACpB,QAAQ,WAAW,OAAO,KAAK,QAAQ,OAAO,KAC5C,YAAY,QAAQ,WAAW,SAAS,WAAW,GAAG;EAsBhD,OACR,IAAI,gBAAgB,QAAQ,WAAW,SAAS,WAAW,aACzD,KACF,QACA,WACA,SACA,WACA,WACA"}

package/dist/CronBuilder-DB35T5dL.cjs

@@ -0,0 +1,116 @@
+const require_rolldown_runtime = require("./rolldown-runtime-y5ARvAq5.cjs");
+require("./Construct-DmvXceVY.cjs");
+const require_construct_interface = require("./construct-interface.cjs");
+const require_functions = require("./functions-ZH60FE7H.cjs");
+const require_clone = require("./clone-UGJpvQnL.cjs");
+//#region src/crons/Cron.ts
+var import_lodash_uniqby = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_functions.require_lodash_uniqby(), 1);
+var Cron = class extends require_functions.Function {
+	_schedule;
+	/**
+	* Where this cron's schedule lives when a server runs it.
+	*
+	* Carried from the worker that built it, which declared it once with
+	* `.database(db)`. Unread on AWS, where the schedule is an EventBridge rule
+	* and nothing in this process fires anything.
+	*
+	* A service rather than the construct, because what reads it is service
+	* discovery in the generated server — which registers services, and failed
+	* on the construct with `service.register is not a function`.
+	*/
+	scheduleStore;
+	static isCron(obj) {
+		return Boolean(obj && obj.__IS_FUNCTION__ === true && obj.type === "dev.geekmidas.function.cron");
+	}
+	constructor(fn, timeout, _schedule, input, outputSchema, services = [], logger, events = [], memorySize, databaseService, constructs = []) {
+		super(fn, timeout, "dev.geekmidas.function.cron", input, outputSchema, services, logger, events, memorySize, void 0, databaseService, constructs);
+		this._schedule = _schedule;
+	}
+	get schedule() {
+		return this._schedule;
+	}
+};
+//#endregion
+//#region src/crons/CronBuilder.ts
+var CronBuilder = class extends require_functions.FunctionBuilder {
+	_schedule;
+	constructor() {
+		super("dev.geekmidas.function.cron");
+	}
+	memorySize(memorySize) {
+		return require_clone.cloneWith(this, { _memorySize: memorySize });
+	}
+	schedule(_expression) {
+		return require_clone.cloneWith(this, { _schedule: _expression });
+	}
+	input(schema) {
+		return require_clone.cloneWith(this, { inputSchema: schema });
+	}
+	output(schema) {
+		return require_clone.cloneWith(this, { outputSchema: schema });
+	}
+	/**
+	* 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(constructs) {
+		const services = require_construct_interface.servicesOf(constructs);
+		return require_clone.cloneWith(this, {
+			_services: (0, import_lodash_uniqby.default)([...this._services, ...services], (s) => s.serviceName),
+			_constructs: require_construct_interface.idsOf(constructs, this._constructs)
+		});
+	}
+	services(services) {
+		return require_clone.cloneWith(this, { _services: (0, import_lodash_uniqby.default)([...this._services, ...services], (s) => s.serviceName) });
+	}
+	logger(logger) {
+		return require_clone.cloneWith(this, { _logger: logger });
+	}
+	/**
+	* Publish `event` to `topic` each time the cron has run successfully —
+	* repeatable, to as many topics as it names. The topic becomes a dependency
+	* as with `.dependsOn([topic])`, so `services.<topic>` is there too.
+	*/
+	event(topic, event) {
+		return this.withEvent(topic, event);
+	}
+	/**
+	* Set the database service for this cron job.
+	* The database will be available in the handler context as `db`.
+	*/
+	database(source) {
+		const service = require_construct_interface.serviceOf(source);
+		return require_clone.cloneWith(this, {
+			_databaseService: service,
+			...require_construct_interface.isConsumable(source) ? { _constructs: require_construct_interface.idsOf([source], this._constructs) } : {}
+		});
+	}
+	handle(fn) {
+		const cron = new Cron(fn, this._timeout, this._schedule, this.inputSchema, this.outputSchema, this._services, this._logger, this._events, this._memorySize, this._databaseService, this._constructs);
+		cron.owner = this._owner;
+		cron.scheduleStore = this._scheduleStore ? require_construct_interface.serviceOf(this._scheduleStore) : void 0;
+		return cron;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "Cron", {
+	enumerable: true,
+	get: function() {
+		return Cron;
+	}
+});
+Object.defineProperty(exports, "CronBuilder", {
+	enumerable: true,
+	get: function() {
+		return CronBuilder;
+	}
+});
+
+//# sourceMappingURL=CronBuilder-DB35T5dL.cjs.map

package/dist/CronBuilder-DB35T5dL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CronBuilder-DB35T5dL.cjs","names":["Function","FunctionBuilder","cloneWith","servicesOf","uniqBy","idsOf","serviceOf","isConsumable"],"sources":["../src/crons/Cron.ts","../src/crons/CronBuilder.ts"],"sourcesContent":["import type { AuditableAction } from '@geekmidas/audit';\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ComposableStandardSchema } from '@geekmidas/schema';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { ConstructType } from '../Construct';\nimport { Function, type FunctionHandler } from '../functions';\nimport type { TopicEvent } from '../publisher';\n\nexport class Cron<\n\tTInput extends ComposableStandardSchema | undefined = undefined,\n\tTServices extends Service[] = [],\n\tTLogger extends Logger = Logger,\n\tOutSchema extends StandardSchemaV1 | undefined = undefined,\n\tTDatabase = undefined,\n\tTDatabaseServiceName extends string = string,\n> extends Function<\n\tTInput,\n\tTServices,\n\tTLogger,\n\tOutSchema,\n\tundefined,\n\tstring,\n\tTDatabase,\n\tTDatabaseServiceName,\n\tAuditableAction<string, unknown>,\n\tFunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>\n> {\n\t/**\n\t * Where this cron's schedule lives when a server runs it.\n\t *\n\t * Carried from the worker that built it, which declared it once with\n\t * `.database(db)`. Unread on AWS, where the schedule is an EventBridge rule\n\t * and nothing in this process fires anything.\n\t *\n\t * A service rather than the construct, because what reads it is service\n\t * discovery in the generated server — which registers services, and failed\n\t * on the construct with `service.register is not a function`.\n\t */\n\tscheduleStore?: Service<string, unknown>;\n\n\tstatic isCron(obj: any): obj is Cron<any, any, any, any> {\n\t\treturn Boolean(\n\t\t\tobj &&\n\t\t\t\t(obj as Function).__IS_FUNCTION__ === true &&\n\t\t\t\tobj.type === ConstructType.Cron,\n\t\t);\n\t}\n\n\tconstructor(\n\t\tfn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>,\n\t\ttimeout?: number,\n\t\tprotected _schedule?: ScheduleExpression,\n\t\tinput?: TInput,\n\t\toutputSchema?: OutSchema,\n\t\tservices: TServices = [] as unknown as TServices,\n\t\tlogger?: TLogger,\n\t\t/** What it publishes once it has run, each to its own topic. */\n\t\tevents: TopicEvent[] = [],\n\t\tmemorySize?: number,\n\t\tdatabaseService?: Service<TDatabaseServiceName, TDatabase>,\n\t\t/**\n\t\t * The construct ids `.dependsOn()` named — last, so no existing positional\n\t\t * argument moves.\n\t\t */\n\t\tconstructs: string[] = [],\n\t) {\n\t\tsuper(\n\t\t\tfn,\n\t\t\ttimeout,\n\t\t\tConstructType.Cron,\n\t\t\tinput,\n\t\t\toutputSchema,\n\t\t\tservices,\n\t\t\tlogger,\n\t\t\tevents,\n\t\t\tmemorySize,\n\t\t\tundefined, // auditorStorageService\n\t\t\tdatabaseService,\n\t\t\tconstructs,\n\t\t);\n\t}\n\n\tget schedule(): ScheduleExpression | undefined {\n\t\treturn this._schedule;\n\t}\n}\n\nexport type RateExpression = `rate(${string})`;\n\ntype CronMinute =\n\t| '*'\n\t| number\n\t| `${number}`\n\t| `${number}-${number}`\n\t| `${number}/${number}`\n\t| `*/${number}`\n\t| `${number},${number}`\n\t| string; // Allow more complex patterns\n\ntype CronHour =\n\t| '*'\n\t| number\n\t| `${number}`\n\t| `${number}-${number}`\n\t| `${number}/${number}`\n\t| `*/${number}`\n\t| `${number},${number}`\n\t| string; // Allow more complex patterns\n\ntype CronDay =\n\t| '*'\n\t| number\n\t| `${number}`\n\t| `${number}-${number}`\n\t| `${number}/${number}`\n\t| `*/${number}`\n\t| `${number},${number}`\n\t| string; // Allow more complex patterns\n\ntype CronMonth =\n\t| '*'\n\t| number\n\t| `${number}`\n\t| `${number}-${number}`\n\t| `${number}/${number}`\n\t| `*/${number}`\n\t| 'JAN'\n\t| 'FEB'\n\t| 'MAR'\n\t| 'APR'\n\t| 'MAY'\n\t| 'JUN'\n\t| 'JUL'\n\t| 'AUG'\n\t| 'SEP'\n\t| 'OCT'\n\t| 'NOV'\n\t| 'DEC'\n\t| string; // Allow more complex patterns\n\ntype CronWeekday =\n\t| '*'\n\t| number\n\t| `${number}`\n\t| `${number}-${number}`\n\t| `${number}/${number}`\n\t| `*/${number}`\n\t| 'SUN'\n\t| 'MON'\n\t| 'TUE'\n\t| 'WED'\n\t| 'THU'\n\t| 'FRI'\n\t| 'SAT'\n\t| `${string}-${string}` // Allow patterns like MON-FRI\n\t| string; // Allow more complex patterns\n\nexport type CronExpression =\n\t`cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;\n\nexport type ScheduleExpression = RateExpression | CronExpression;\n","import type { Logger } from '@geekmidas/logger';\nimport type {\n\tComposableStandardSchema,\n\tInferStandardSchema,\n} from '@geekmidas/schema';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport uniqBy from 'lodash.uniqby';\nimport { ConstructType } from '../Construct';\nimport { cloneWith } from '../clone';\nimport {\n\ttype Consumable,\n\tidsOf,\n\tisConsumable,\n\ttype ServicesOf,\n\tserviceOf,\n\tservicesOf,\n} from '../construct-interface';\nimport { FunctionBuilder, type FunctionHandler } from '../functions';\nimport type { EventFor } from '../publisher';\nimport type { Topic } from '../topic/Topic';\nimport { Cron, type ScheduleExpression } from './Cron';\n\nexport class CronBuilder<\n\tTInput extends ComposableStandardSchema,\n\tTServices extends Service[],\n\tTLogger extends Logger = Logger,\n\tOutSchema extends StandardSchemaV1 | undefined = undefined,\n\tTDatabase = undefined,\n\tTDatabaseServiceName extends string = string,\n> extends FunctionBuilder<\n\tTInput,\n\tOutSchema,\n\tTServices,\n\tTLogger,\n\tundefined,\n\tstring,\n\tTDatabase,\n\tTDatabaseServiceName\n> {\n\tprivate _schedule?: ScheduleExpression;\n\n\tconstructor() {\n\t\tsuper(ConstructType.Cron);\n\t}\n\n\toverride memorySize(memorySize: number): this {\n\t\treturn cloneWith(this, { _memorySize: memorySize });\n\t}\n\n\tschedule(\n\t\t_expression: ScheduleExpression,\n\t): CronBuilder<\n\t\tTInput,\n\t\tTServices,\n\t\tTLogger,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\treturn cloneWith(this, { _schedule: _expression });\n\t}\n\n\toverride input<T extends ComposableStandardSchema>(\n\t\tschema: T,\n\t): CronBuilder<\n\t\tT,\n\t\tTServices,\n\t\tTLogger,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\treturn cloneWith(this, {\n\t\t\tinputSchema: schema as unknown as TInput,\n\t\t}) as unknown as CronBuilder<\n\t\t\tT,\n\t\t\tTServices,\n\t\t\tTLogger,\n\t\t\tOutSchema,\n\t\t\tTDatabase,\n\t\t\tTDatabaseServiceName\n\t\t>;\n\t}\n\n\toverride output<T extends StandardSchemaV1>(\n\t\tschema: T,\n\t): CronBuilder<\n\t\tTInput,\n\t\tTServices,\n\t\tTLogger,\n\t\tT,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\treturn cloneWith(this, {\n\t\t\toutputSchema: schema as unknown as OutSchema,\n\t\t}) as unknown as CronBuilder<\n\t\t\tTInput,\n\t\t\tTServices,\n\t\t\tTLogger,\n\t\t\tT,\n\t\t\tTDatabase,\n\t\t\tTDatabaseServiceName\n\t\t>;\n\t}\n\n\t/**\n\t * Depend on constructs — a database, a bucket, a mail sender, a queue, a\n\t * topic.\n\t *\n\t * It records the edge and dissolves each construct's client into the\n\t * handler's service record under the construct's own id, so\n\t * `.dependsOn([uploads])` is what makes `services.uploads` exist and type.\n\t *\n\t * Constructs only. A `Service` does not match the shape, which is what keeps\n\t * env sniffing confined to `.services()` and the explicit lift.\n\t */\n\toverride dependsOn<const T extends readonly Consumable[]>(\n\t\tconstructs: T,\n\t): CronBuilder<\n\t\tTInput,\n\t\t[...TServices, ...ServicesOf<T>],\n\t\tTLogger,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\t// Both halves of the edge, from one call and one clone: the services the\n\t\t// handler runs with, and the ids the manifest records. Recording them\n\t\t// separately is what let them drift apart.\n\t\t//\n\t\t// `servicesOf` is the half that validates, so it runs first — recording\n\t\t// ids ahead of it left a caught `NotAConstruct` with `undefined` already\n\t\t// on a `string[]`.\n\t\tconst services = servicesOf(constructs) as unknown as Service[];\n\n\t\treturn cloneWith(this, {\n\t\t\t_services: uniqBy(\n\t\t\t\t[...this._services, ...services],\n\t\t\t\t(s: Service) => s.serviceName,\n\t\t\t),\n\t\t\t_constructs: idsOf(constructs, this._constructs),\n\t\t}) as unknown as CronBuilder<\n\t\t\tTInput,\n\t\t\t[...TServices, ...ServicesOf<T>],\n\t\t\tTLogger,\n\t\t\tOutSchema,\n\t\t\tTDatabase,\n\t\t\tTDatabaseServiceName\n\t\t>;\n\t}\n\n\toverride services<T extends Service[]>(\n\t\tservices: T,\n\t): CronBuilder<\n\t\tTInput,\n\t\t[...TServices, ...T],\n\t\tTLogger,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\treturn cloneWith(this, {\n\t\t\t_services: uniqBy(\n\t\t\t\t[...this._services, ...services],\n\t\t\t\t(s) => s.serviceName,\n\t\t\t) as TServices,\n\t\t}) as unknown as CronBuilder<\n\t\t\tTInput,\n\t\t\t[...TServices, ...T],\n\t\t\tTLogger,\n\t\t\tOutSchema,\n\t\t\tTDatabase,\n\t\t\tTDatabaseServiceName\n\t\t>;\n\t}\n\n\toverride logger<T extends Logger>(\n\t\tlogger: T,\n\t): CronBuilder<\n\t\tTInput,\n\t\tTServices,\n\t\tT,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\treturn cloneWith(this, {\n\t\t\t_logger: logger as unknown as TLogger,\n\t\t}) as unknown as CronBuilder<\n\t\t\tTInput,\n\t\t\tTServices,\n\t\t\tT,\n\t\t\tOutSchema,\n\t\t\tTDatabase,\n\t\t\tTDatabaseServiceName\n\t\t>;\n\t}\n\n\t/**\n\t * Publish `event` to `topic` each time the cron has run successfully —\n\t * repeatable, to as many topics as it names. The topic becomes a dependency\n\t * as with `.dependsOn([topic])`, so `services.<topic>` is there too.\n\t */\n\toverride event<TTopic extends Topic<any, any>>(\n\t\ttopic: TTopic,\n\t\tevent: EventFor<TTopic, InferStandardSchema<OutSchema>>,\n\t): CronBuilder<\n\t\tTInput,\n\t\t[...TServices, TTopic['service']],\n\t\tTLogger,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\treturn this.withEvent(topic, event as never) as unknown as CronBuilder<\n\t\t\tTInput,\n\t\t\t[...TServices, TTopic['service']],\n\t\t\tTLogger,\n\t\t\tOutSchema,\n\t\t\tTDatabase,\n\t\t\tTDatabaseServiceName\n\t\t>;\n\t}\n\n\t/**\n\t * Set the database service for this cron job.\n\t * The database will be available in the handler context as `db`.\n\t */\n\toverride database<T, TName extends string>(\n\t\tsource: Consumable<TName, T> | Service<TName, T>,\n\t): CronBuilder<TInput, TServices, TLogger, OutSchema, T, TName> {\n\t\tconst service = serviceOf(source);\n\n\t\treturn cloneWith(this, {\n\t\t\t_databaseService: service as unknown as Service<\n\t\t\t\tTDatabaseServiceName,\n\t\t\t\tTDatabase\n\t\t\t>,\n\t\t\t// The edge, as `.dependsOn()` records one — see EndpointFactory.\n\t\t\t...(isConsumable(source)\n\t\t\t\t? { _constructs: idsOf([source], this._constructs) }\n\t\t\t\t: {}),\n\t\t}) as unknown as CronBuilder<\n\t\t\tTInput,\n\t\t\tTServices,\n\t\t\tTLogger,\n\t\t\tOutSchema,\n\t\t\tT,\n\t\t\tTName\n\t\t>;\n\t}\n\n\toverride handle(\n\t\tfn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>,\n\t): Cron<\n\t\tTInput,\n\t\tTServices,\n\t\tTLogger,\n\t\tOutSchema,\n\t\tTDatabase,\n\t\tTDatabaseServiceName\n\t> {\n\t\tconst cron = new Cron(\n\t\t\tfn,\n\t\t\tthis._timeout,\n\t\t\tthis._schedule,\n\t\t\tthis.inputSchema,\n\t\t\tthis.outputSchema,\n\t\t\tthis._services,\n\t\t\tthis._logger,\n\t\t\tthis._events,\n\t\t\tthis._memorySize,\n\t\t\tthis._databaseService,\n\t\t\tthis._constructs,\n\t\t);\n\n\t\t// Which process runs it. Carried from the factory rather than inferred\n\t\t// from the directory the file happens to sit in.\n\t\tcron.owner = this._owner;\n\n\t\t// And where that process keeps the schedule, when a server is what runs\n\t\t// it. Declared once on the worker rather than repeated per cron.\n\t\tcron.scheduleStore = this._scheduleStore\n\t\t\t? serviceOf(this._scheduleStore as Consumable<string, unknown>)\n\t\t\t: undefined;\n\n\t\t// No reset. `.handle()` reads this builder and leaves it alone, so a\n\t\t// configured base — `const fn = f.logger(log).timeout(60_000)` — keeps\n\t\t// its configuration for every construct built from it. The reset that\n\t\t// used to be here wiped the base on first use, which made a base usable\n\t\t// exactly once, and quietly reverted the logger to the default.\n\n\t\treturn cron;\n\t}\n}\n"],"mappings":";;;;;;;AAUA,IAAa,OAAb,cAOUA,kBAAAA,SAWR;CAyBU;;;;;;;;;;;;CAbX;CAEA,OAAO,OAAO,KAA2C;EACxD,OAAO,QACN,OACE,IAAiB,oBAAoB,QACtC,IAAI,SAAA,6BACN;CACD;CAEA,YACC,IACA,SACA,WACA,OACA,cACA,WAAsB,CAAC,GACvB,QAEA,SAAuB,CAAC,GACxB,YACA,iBAKA,aAAuB,CAAC,GACvB;EACD,MACC,IACA,SAAA,+BAEA,OACA,cACA,UACA,QACA,QACA,YACA,KAAA,GACA,iBACA,UACD;EA5BU,KAAA,YAAA;CA6BX;CAEA,IAAI,WAA2C;EAC9C,OAAO,KAAK;CACb;AACD;;;AChEA,IAAa,cAAb,cAOUC,kBAAAA,gBASR;CACD;CAEA,cAAc;EACb,MAAA,6BAAwB;CACzB;CAEA,WAAoB,YAA0B;EAC7C,OAAOC,cAAAA,UAAU,MAAM,EAAE,aAAa,WAAW,CAAC;CACnD;CAEA,SACC,aAQC;EACD,OAAOA,cAAAA,UAAU,MAAM,EAAE,WAAW,YAAY,CAAC;CAClD;CAEA,MACC,QAQC;EACD,OAAOA,cAAAA,UAAU,MAAM,EACtB,aAAa,OACd,CAAC;CAQF;CAEA,OACC,QAQC;EACD,OAAOA,cAAAA,UAAU,MAAM,EACtB,cAAc,OACf,CAAC;CAQF;;;;;;;;;;;;CAaA,UACC,YAQC;EAQD,MAAM,WAAWC,4BAAAA,WAAW,UAAU;EAEtC,OAAOD,cAAAA,UAAU,MAAM;GACtB,YAAA,GAAWE,qBAAAA,QAAAA,CACV,CAAC,GAAG,KAAK,WAAW,GAAG,QAAQ,IAC9B,MAAe,EAAE,WACnB;GACA,aAAaC,4BAAAA,MAAM,YAAY,KAAK,WAAW;EAChD,CAAC;CAQF;CAEA,SACC,UAQC;EACD,OAAOH,cAAAA,UAAU,MAAM,EACtB,YAAA,GAAWE,qBAAAA,QAAAA,CACV,CAAC,GAAG,KAAK,WAAW,GAAG,QAAQ,IAC9B,MAAM,EAAE,WACV,EACD,CAAC;CAQF;CAEA,OACC,QAQC;EACD,OAAOF,cAAAA,UAAU,MAAM,EACtB,SAAS,OACV,CAAC;CAQF;;;;;;CAOA,MACC,OACA,OAQC;EACD,OAAO,KAAK,UAAU,OAAO,KAAc;CAQ5C;;;;;CAMA,SACC,QAC+D;EAC/D,MAAM,UAAUI,4BAAAA,UAAU,MAAM;EAEhC,OAAOJ,cAAAA,UAAU,MAAM;GACtB,kBAAkB;GAKlB,GAAIK,4BAAAA,aAAa,MAAM,IACpB,EAAE,aAAaF,4BAAAA,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,EAAE,IACjD,CAAC;EACL,CAAC;CAQF;CAEA,OACC,IAQC;EACD,MAAM,OAAO,IAAI,KAChB,IACA,KAAK,UACL,KAAK,WACL,KAAK,aACL,KAAK,cACL,KAAK,WACL,KAAK,SACL,KAAK,SACL,KAAK,aACL,KAAK,kBACL,KAAK,WACN;EAIA,KAAK,QAAQ,KAAK;EAIlB,KAAK,gBAAgB,KAAK,iBACvBC,4BAAAA,UAAU,KAAK,cAA6C,IAC5D,KAAA;EAQH,OAAO;CACR;AACD"}

package/dist/CronBuilder-Dv0IlZs0.mjs

@@ -0,0 +1,104 @@
+import { o as __toESM } from "./Construct-BO1X-kt9.mjs";
+import { idsOf, isConsumable, serviceOf, servicesOf } from "./construct-interface.mjs";
+import { n as Function, o as require_lodash_uniqby, t as FunctionBuilder } from "./functions-DCIfCRR-.mjs";
+import { t as cloneWith } from "./clone-EKNovYHu.mjs";
+//#region src/crons/Cron.ts
+var import_lodash_uniqby = /* @__PURE__ */ __toESM(require_lodash_uniqby(), 1);
+var Cron = class extends Function {
+	_schedule;
+	/**
+	* Where this cron's schedule lives when a server runs it.
+	*
+	* Carried from the worker that built it, which declared it once with
+	* `.database(db)`. Unread on AWS, where the schedule is an EventBridge rule
+	* and nothing in this process fires anything.
+	*
+	* A service rather than the construct, because what reads it is service
+	* discovery in the generated server — which registers services, and failed
+	* on the construct with `service.register is not a function`.
+	*/
+	scheduleStore;
+	static isCron(obj) {
+		return Boolean(obj && obj.__IS_FUNCTION__ === true && obj.type === "dev.geekmidas.function.cron");
+	}
+	constructor(fn, timeout, _schedule, input, outputSchema, services = [], logger, events = [], memorySize, databaseService, constructs = []) {
+		super(fn, timeout, "dev.geekmidas.function.cron", input, outputSchema, services, logger, events, memorySize, void 0, databaseService, constructs);
+		this._schedule = _schedule;
+	}
+	get schedule() {
+		return this._schedule;
+	}
+};
+//#endregion
+//#region src/crons/CronBuilder.ts
+var CronBuilder = class extends FunctionBuilder {
+	_schedule;
+	constructor() {
+		super("dev.geekmidas.function.cron");
+	}
+	memorySize(memorySize) {
+		return cloneWith(this, { _memorySize: memorySize });
+	}
+	schedule(_expression) {
+		return cloneWith(this, { _schedule: _expression });
+	}
+	input(schema) {
+		return cloneWith(this, { inputSchema: schema });
+	}
+	output(schema) {
+		return cloneWith(this, { outputSchema: schema });
+	}
+	/**
+	* 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(constructs) {
+		const services = servicesOf(constructs);
+		return cloneWith(this, {
+			_services: (0, import_lodash_uniqby.default)([...this._services, ...services], (s) => s.serviceName),
+			_constructs: idsOf(constructs, this._constructs)
+		});
+	}
+	services(services) {
+		return cloneWith(this, { _services: (0, import_lodash_uniqby.default)([...this._services, ...services], (s) => s.serviceName) });
+	}
+	logger(logger) {
+		return cloneWith(this, { _logger: logger });
+	}
+	/**
+	* Publish `event` to `topic` each time the cron has run successfully —
+	* repeatable, to as many topics as it names. The topic becomes a dependency
+	* as with `.dependsOn([topic])`, so `services.<topic>` is there too.
+	*/
+	event(topic, event) {
+		return this.withEvent(topic, event);
+	}
+	/**
+	* Set the database service for this cron job.
+	* The database will be available in the handler context as `db`.
+	*/
+	database(source) {
+		const service = serviceOf(source);
+		return cloneWith(this, {
+			_databaseService: service,
+			...isConsumable(source) ? { _constructs: idsOf([source], this._constructs) } : {}
+		});
+	}
+	handle(fn) {
+		const cron = new Cron(fn, this._timeout, this._schedule, this.inputSchema, this.outputSchema, this._services, this._logger, this._events, this._memorySize, this._databaseService, this._constructs);
+		cron.owner = this._owner;
+		cron.scheduleStore = this._scheduleStore ? serviceOf(this._scheduleStore) : void 0;
+		return cron;
+	}
+};
+//#endregion
+export { Cron as n, CronBuilder as t };
+
+//# sourceMappingURL=CronBuilder-Dv0IlZs0.mjs.map