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

package/dist/discover-CSW_BMWa.d.cts

@@ -0,0 +1,125 @@
+import { n as Sandbox } from "./sandbox-CdKgQ3XU.cjs";
+import { ConstructManifest, Declaration } from "@geekmidas/manifest";
+//#region src/reconcile/discover.d.ts
+/** The construct face discovery needs: an id, and the ability to declare. */
+interface Declarable {
+  id: string;
+  declare(): Declaration[];
+}
+/**
+ * Whether a module export is a construct.
+ *
+ * Deliberately loose about what else it carries — a construct that also has a
+ * `service` is still a construct, and requiring one would exclude the kinds that
+ * own no address.
+ */
+declare function isDeclarable(value: unknown): value is Declarable;
+interface DiscoverOptions {
+  /** The glob(s) to search. One pattern, not one per kind. */
+  patterns: string | readonly string[];
+  cwd?: string;
+  /**
+   * Re-import changed modules, for the dev watcher.
+   *
+   * A single glob makes discovery more central, not less: a new construct file
+   * has to be picked up on `add`, not only on `change`.
+   */
+  bustCache?: boolean;
+  /**
+   * Filled in with where each construct was found, when provided.
+   *
+   * Discovery is the only thing that knows: it globbed the files and imported
+   * them. Everything downstream that needs to *write* an import — the build,
+   * generating a server entry that reads a surface's logger — would otherwise
+   * have to be told the path in config, which is the string this removes.
+   *
+   * An out-parameter rather than a second return value so that every existing
+   * caller, which wants the manifest and nothing else, is unchanged.
+   */
+  sources?: Record<string, ConstructSource>;
+  /**
+   * Filled in, when provided, with the ids each owner's runnables declared an
+   * edge to — keyed by the surface an endpoint was built from, or the worker
+   * a cron or subscriber was.
+   *
+   * A runnable is not a declaration: a surface's endpoints are found by the
+   * glob, not listed by the surface, so its node says `endpoints: []` until a
+   * build folds the routes in. Anything deciding what an app's process reaches
+   * — which keys its container is given — needs those edges before any build,
+   * and discovery is already importing the files they are in.
+   */
+  runnables?: Record<string, string[]>;
+  /**
+   * Filled in, when provided, with the files each worker's background work is
+   * declared in — its crons, queue consumers and topic subscribers — keyed by
+   * the worker.
+   *
+   * What says which app's build carries a worker's entry: the one whose
+   * directory holds its work. A worker declares no path of its own.
+   */
+  background?: Record<string, string[]>;
+  /**
+   * Filled in, when provided, with each worker's topic subscribers — by the
+   * export a push route is named after, and the topic each is bound to —
+   * keyed by the worker.
+   *
+   * What says which worker SNS pushes to, and on which paths: a build bound
+   * for a server records no subscriber in the manifest, because none has a
+   * handler of its own there.
+   */
+  subscribers?: Record<string, BoundSubscriber[]>;
+  /**
+   * Import the construct modules in this sandbox rather than in this
+   * process. Defaults to the run's own (`withSandbox`), so a deploy's every
+   * discovery — the engine's included — happens there; with neither, they
+   * are imported here, as before.
+   */
+  sandbox?: Sandbox;
+}
+/** A worker's topic subscriber, as discovery found it. */
+interface BoundSubscriber {
+  /** Its export — what its push route is named after. */
+  name: string;
+  /** The topic it is bound to, by id. */
+  topic: string;
+}
+/** Importing a construct module, or declaring one, threw in the sandbox. */
+declare class ConstructDiscoveryFailed extends Error {
+  readonly errorName: string;
+  readonly detail: string;
+  constructor(errorName: string, detail: string);
+}
+/**
+ * The constructs' declarations hold something that is not data, and the
+ * sandbox they were discovered in hands the deploy nothing but data.
+ */
+declare class ConstructsNotSerializable extends Error {
+  readonly paths: readonly string[];
+  constructor(paths: readonly string[]);
+}
+/** Where a construct was declared, and under what name. */
+interface ConstructSource {
+  /** Absolute path to the module that exported it. */
+  file: string;
+  /** The name it was exported as — what an import statement has to say. */
+  exportName: string;
+  /**
+   * The exported construct itself.
+   *
+   * What a declaration cannot say — whether it serves itself — the object can
+   * be asked, and discovery already imported it.
+   */
+  construct: unknown;
+}
+/**
+ * Build the construct manifest for a project.
+ *
+ * Runs the manifest's own validation before returning, so an app is wrong here
+ * — where the error names a file — rather than at deploy.
+ *
+ * @throws {DuplicateConstruct} when two exports claim one id.
+ */
+declare function discover(options: DiscoverOptions): Promise<ConstructManifest>;
+//#endregion
+export { isDeclarable as a, discover as i, ConstructsNotSerializable as n, DiscoverOptions as r, ConstructDiscoveryFailed as t };
+//# sourceMappingURL=discover-CSW_BMWa.d.cts.map

package/dist/discover-CSW_BMWa.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-CSW_BMWa.d.cts","names":[],"sources":["../src/reconcile/discover.ts"],"mappings":";;;;UAsCU;EACT;EACA,WAAW;;;;;;;;;iBAUI,aAAa,iBAAiB,SAAS;UAYtC;;EAEhB;EACA;;;;;;;EAOA;;;;;;;;;;;;EAYA,UAAU,eAAe;;;;;;;;;;;;EAYzB,YAAY;;;;;;;;;EASZ,aAAa;;;;;;;;;;EAUb,cAAc,eAAe;;;;;;;EAO7B,UAAU;;;UAIM;;EAEhB;;EAEA;;;cA8GY,iCAAiC;WAEnC;WACA;EAFV,YACU,mBACA;;;;;;cAWE,kCAAkC;WACzB;EAArB,YAAqB;;;UAYL;;EAEhB;;EAEA;;;;;;;EAOA;;;;;;;;;;iBAWqB,SACrB,SAAS,kBACP,QAAQ"}