@lpdjs/firestore-repo-service 2.1.2 → 2.1.3

package/dist/sync/index.d.cts

@@ -1,70 +1,7 @@
-import { L as LogicalType, S as SqlDialect, a as SqlColumn, R as RepoSyncConfig, b as SqlTableDef, G as GenerateDDLConfig, c as SqlAdapter, d as SyncEvent, e as SyncWorkerConfig, f as SyncTriggersConfig, F as FirestoreSyncConfig, g as SyncAdminConfig, P as PubSubClientDep } from '../types-PzZ0APQ_.cjs';
-export { j as FirestoreTriggersDep, k as PubSubHandlerDep, l as SyncAdminBasicAuth, m as SyncAdminFeaturesFlag, i as SyncDeps, h as SyncOperation } from '../types-PzZ0APQ_.cjs';
+import { S as SqlAdapter, a as SyncEvent, b as adminsyncConfig, R as RepoSyncConfig, P as PubSubClientDep, F as FirestoreSyncConfig, c as SqlDialect, d as SqlColumn, e as SqlTableDef, G as GenerateDDLConfig, L as LogicalType, f as SyncTriggersConfig, g as SyncWorkerConfig } from '../types-BG1kGsLO.cjs';
+export { h as FirestoreTriggersDep, O as OrFactory, i as PubSubHandlerDep, j as SyncDeps, k as SyncOperation, l as adminsyncBasicAuth, m as adminsyncFeaturesFlag } from '../types-BG1kGsLO.cjs';
 import { z } from 'zod';
 
-declare function zodTypeToLogical(schema: z.ZodType): LogicalType;
-interface ZodSchemaToColumnsOptions {
-    primaryKey?: string;
-    exclude?: string[];
-    columnMap?: Record<string, string>;
-}
-/**
- * Convert a Zod object schema into an array of {@link SqlColumn} definitions
- * suitable for SQL table creation.
- *
- * Nested ZodObject fields are recursively flattened into separate columns
- * with underscore-separated names (e.g. `address.street` → `address_street`).
- * Arrays become JSON columns.
- */
-declare function zodSchemaToColumns(schema: z.ZodObject<any>, dialect: SqlDialect, options?: ZodSchemaToColumnsOptions): SqlColumn[];
-
-/**
- * Convert a single Firestore value into a SQL-safe primitive.
- *
- * Complex types (arrays, GeoPoints, binary) become JSON strings.
- * Primitives pass through unchanged.
- * Objects are NOT stringified here — they are flattened by serializeDocument.
- */
-declare function serializeValue(value: unknown): unknown;
-/**
- * Serialize a full Firestore document into a flat object of SQL-safe values.
- *
- * Nested objects are flattened into underscore-separated column names
- * (e.g. `address.street` → `address_street`). Arrays become JSON strings.
- * Applies optional field exclusions and column renames from `options`.
- */
-declare function serializeDocument(doc: Record<string, unknown>, options?: Pick<RepoSyncConfig, "exclude" | "columnMap">): Record<string, unknown>;
-
-/**
- * DDL generator — produces CREATE TABLE / ALTER TABLE statements from
- * SqlColumn definitions and a SqlDialect.
- *
- * `generateDDL()` is the public entry point: it walks a repository mapping,
- * converts each repo's Zod schema to columns, and returns the full DDL
- * as a single string.
- */
-
-/**
- * Generate a CREATE TABLE statement from a table definition.
- * Delegates to the dialect for syntax specifics.
- */
-declare function createTableDDL(dialect: SqlDialect, table: SqlTableDef): string;
-/**
- * Generate ALTER TABLE ADD COLUMN statements for columns missing from an
- * existing table.
- */
-declare function addColumnsDDL(dialect: SqlDialect, tableName: string, columns: SqlColumn[]): string;
-/**
- * Walk a full repository mapping and produce DDL for every repo that has a
- * Zod schema attached.
- *
- * @param repoMapping - Object whose values expose `.schema` (ZodObject)
- * @param dialect     - Target SQL dialect
- * @param config      - Optional per-repo overrides (table name, exclusions…)
- * @returns Complete DDL string (one CREATE TABLE per repo, separated by newlines)
- */
-declare function generateDDL<M extends Record<string, any>>(repoMapping: M, dialect: SqlDialect, config?: GenerateDDLConfig<NoInfer<M>>): string;
-
 /**
  * Per-repo in-memory batch buffer.
  *
@@ -115,35 +52,127 @@ declare class SyncQueue {
 }
 
 /**
- * PubSub worker — creates a Cloud Function that receives {@link SyncEvent}
- * messages from PubSub, routes them to per-repo {@link SyncQueue}s, and
- * flushes batches to the configured {@link SqlAdapter}.
+ * Sync Admin — optional HTTP endpoint for inspecting and managing the
+ * Firestore → SQL sync pipeline.
  *
- * Dependencies (`firebase-functions`, `@google-cloud/pubsub`) are injected
- * via the `deps` config property.
+ * Features (gated by `featuresFlag`):
+ *  - **healthCheck** — compare expected Zod-derived columns vs actual SQL columns
+ *  - **manualSync** — force re-sync all documents in a Firestore collection
+ *  - **viewQueue** — inspect pending items in the per-repo SyncQueue
+ *
+ * @example
+ * ```typescript
+ * const sync = createFirestoreSync(repos, {
+ *   // …deps, adapter, etc.
+ *   admin: {
+ *     auth: { type: "basic", username: "admin", password: "secret" },
+ *     featuresFlag: { healthCheck: true, manualSync: true, viewQueue: true },
+ *   },
+ * });
+ *
+ * export const adminsync = onRequest(sync.adminHandler!);
+ * ```
  */
 
 /**
- * Create a PubSub-triggered Cloud Function that syncs Firestore changes
- * to a SQL database.
+ * Create the sync admin HTTP handler.
  *
- * Returns an object with:
- * - `createHandler` — creates a Cloud Function for a PubSub topic
- * - `handleMessage` — process a SyncEvent directly (for testing)
- * - `queues` — internal SyncQueue map (for testing / manual flush)
- * - `shutdown()` — flush all queues and stop timers
+ * @param repoMapping   - The configured repository mapping
+ * @param adapter       - The SQL adapter (e.g. BigQueryAdapter)
+ * @param queues        - Live queue map from the worker
+ * @param handleMessage - Direct SyncEvent processor from the worker
+ * @param config        - Admin-specific config (auth, basePath, features)
+ * @param repoConfigs   - Per-repo sync config (tableName, exclude, columnMap…)
+ * @param pubsub        - PubSub client (needed for configCheck)
+ * @param topicPrefix   - PubSub topic prefix (needed for configCheck)
  */
-declare function createSyncWorker<M extends Record<string, any>>(repoMapping: M, config: SyncWorkerConfig<NoInfer<M>>): {
-    /** Process a SyncEvent directly (for testing or custom PubSub integration). */
-    handleMessage: (syncEvent: SyncEvent) => Promise<void>;
-    /** Create a Cloud Function handler for a specific PubSub topic. */
-    createHandler: (topicName: string) => any;
-    /** Internal queue map (for testing). */
+declare function createadminsyncServer(repoMapping: Record<string, any>, adapter: SqlAdapter, queues: Map<string, SyncQueue>, handleMessage: (event: SyncEvent) => Promise<void>, config: adminsyncConfig, repoConfigs: Record<string, RepoSyncConfig<string> | undefined>, pubsub?: PubSubClientDep, topicPrefix?: string): (req: any, res: any) => Promise<void>;
+
+/**
+ * Unified wrapper — combines triggers + worker into a single call.
+ *
+ * @example
+ * ```typescript
+ * import * as firestoreTriggers from "firebase-functions/v2/firestore";
+ * import * as pubsubHandler from "firebase-functions/v2/pubsub";
+ * import { PubSub } from "@google-cloud/pubsub";
+ *
+ * const sync = createFirestoreSync(repos, {
+ *   deps: { firestoreTriggers, pubsubHandler, pubsub: new PubSub() },
+ *   adapter,
+ *   topicPrefix: "firestore-sync",
+ *   autoMigrate: true,
+ *   admin: {
+ *     auth: { type: "basic", username: "admin", password: "secret" },
+ *     featuresFlag: { healthCheck: true, manualSync: true, viewQueue: true },
+ *   },
+ *   repos: {
+ *     users: { exclude: ["documentPath"], columnMap: { docId: "user_id" } },
+ *     posts: { columnMap: { docId: "post_id" } },
+ *   },
+ * });
+ *
+ * // Triggers + PubSub handlers
+ * export const { users_onCreate, users_onUpdate, users_onDelete, sync_users } = sync.functions;
+ *
+ * // Admin endpoint — wrap with onRequest yourself
+ * export const adminsync = onRequest(sync.adminHandler!);
+ *
+ * // Or pass onRequest in admin config to auto-add to sync.functions:
+ * // admin: { onRequest, ... } → export const { adminsync } = sync.functions;
+ * ```
+ */
+
+declare function createFirestoreSync<M extends Record<string, any>>(repoMapping: M, config: FirestoreSyncConfig<NoInfer<M>>): {
+    /** All Cloud Functions (triggers + handlers + optional admin) — spread into exports */
+    functions: Record<string, any>;
+    /**
+     * Raw admin HTTP handler — wrap with `onRequest()` yourself if you
+     * didn't pass `onRequest` in the admin config.
+     * @example
+     * ```ts
+     * export const adminsync = onRequest(sync.adminHandler!);
+     * ```
+     */
+    adminHandler: ((req: any, res: any) => Promise<void>) | null;
+    /** Process a SyncEvent directly (for testing) */
+    handleMessage: (event: SyncEvent) => Promise<void>;
+    /** Internal queue map (for testing) */
     queues: Map<string, SyncQueue>;
-    /** Flush all queues and stop timers. */
-    shutdown(): Promise<void>;
+    /** Flush all queues and stop timers */
+    shutdown: () => Promise<void>;
 };
 
+/**
+ * DDL generator — produces CREATE TABLE / ALTER TABLE statements from
+ * SqlColumn definitions and a SqlDialect.
+ *
+ * `generateDDL()` is the public entry point: it walks a repository mapping,
+ * converts each repo's Zod schema to columns, and returns the full DDL
+ * as a single string.
+ */
+
+/**
+ * Generate a CREATE TABLE statement from a table definition.
+ * Delegates to the dialect for syntax specifics.
+ */
+declare function createTableDDL(dialect: SqlDialect, table: SqlTableDef): string;
+/**
+ * Generate ALTER TABLE ADD COLUMN statements for columns missing from an
+ * existing table.
+ */
+declare function addColumnsDDL(dialect: SqlDialect, tableName: string, columns: SqlColumn[]): string;
+/**
+ * Walk a full repository mapping and produce DDL for every repo that has a
+ * Zod schema attached.
+ *
+ * @param repoMapping - Object whose values expose `.schema` (ZodObject)
+ * @param dialect     - Target SQL dialect
+ * @param config      - Optional per-repo overrides (table name, exclusions…)
+ * @returns Complete DDL string (one CREATE TABLE per repo, separated by newlines)
+ */
+declare function generateDDL<M extends Record<string, any>>(repoMapping: M, dialect: SqlDialect, config?: GenerateDDLConfig<NoInfer<M>>): string;
+
 /**
  * Migration manager — generates DDL and optionally auto-migrates SQL tables
  * to match the Zod schemas defined in a repository mapping.
@@ -169,6 +198,39 @@ interface MigrateResult {
  */
 declare function autoMigrate<M extends Record<string, any>>(repoMapping: M, adapter: SqlAdapter, config?: GenerateDDLConfig<NoInfer<M>>): Promise<MigrateResult>;
 
+declare function zodTypeToLogical(schema: z.ZodType): LogicalType;
+interface ZodSchemaToColumnsOptions {
+    primaryKey?: string;
+    exclude?: string[];
+    columnMap?: Record<string, string>;
+}
+/**
+ * Convert a Zod object schema into an array of {@link SqlColumn} definitions
+ * suitable for SQL table creation.
+ *
+ * Nested ZodObject fields are recursively flattened into separate columns
+ * with underscore-separated names (e.g. `address.street` → `address_street`).
+ * Arrays become JSON columns.
+ */
+declare function zodSchemaToColumns(schema: z.ZodObject<any>, dialect: SqlDialect, options?: ZodSchemaToColumnsOptions): SqlColumn[];
+
+/**
+ * Convert a single Firestore value into a SQL-safe primitive.
+ *
+ * Complex types (arrays, GeoPoints, binary) become JSON strings.
+ * Primitives pass through unchanged.
+ * Objects are NOT stringified here — they are flattened by serializeDocument.
+ */
+declare function serializeValue(value: unknown): unknown;
+/**
+ * Serialize a full Firestore document into a flat object of SQL-safe values.
+ *
+ * Nested objects are flattened into underscore-separated column names
+ * (e.g. `address.street` → `address_street`). Arrays become JSON strings.
+ * Applies optional field exclusions and column renames from `options`.
+ */
+declare function serializeDocument(doc: Record<string, unknown>, options?: Pick<RepoSyncConfig, "exclude" | "columnMap">): Record<string, unknown>;
+
 /**
  * Firestore Cloud Function triggers that publish {@link SyncEvent}s to
  * Google Cloud PubSub.
@@ -211,95 +273,33 @@ declare function autoMigrate<M extends Record<string, any>>(repoMapping: M, adap
 declare function createSyncTriggers<M extends Record<string, any>>(repoMapping: M, config: SyncTriggersConfig<NoInfer<M>>): Record<string, any>;
 
 /**
- * Unified wrapper — combines triggers + worker into a single call.
- *
- * @example
- * ```typescript
- * import * as firestoreTriggers from "firebase-functions/v2/firestore";
- * import * as pubsubHandler from "firebase-functions/v2/pubsub";
- * import { PubSub } from "@google-cloud/pubsub";
- *
- * const sync = createFirestoreSync(repos, {
- *   deps: { firestoreTriggers, pubsubHandler, pubsub: new PubSub() },
- *   adapter,
- *   topicPrefix: "firestore-sync",
- *   autoMigrate: true,
- *   admin: {
- *     auth: { type: "basic", username: "admin", password: "secret" },
- *     featuresFlag: { healthCheck: true, manualSync: true, viewQueue: true },
- *   },
- *   repos: {
- *     users: { exclude: ["documentPath"], columnMap: { docId: "user_id" } },
- *     posts: { columnMap: { docId: "post_id" } },
- *   },
- * });
- *
- * // Triggers + PubSub handlers
- * export const { users_onCreate, users_onUpdate, users_onDelete, sync_users } = sync.functions;
- *
- * // Admin endpoint — wrap with onRequest yourself
- * export const syncAdmin = onRequest(sync.adminHandler!);
- *
- * // Or pass onRequest in admin config to auto-add to sync.functions:
- * // admin: { onRequest, ... } → export const { syncAdmin } = sync.functions;
- * ```
- */
-
-declare function createFirestoreSync<M extends Record<string, any>>(repoMapping: M, config: FirestoreSyncConfig<NoInfer<M>>): {
-    /** All Cloud Functions (triggers + handlers + optional admin) — spread into exports */
-    functions: Record<string, any>;
-    /**
-     * Raw admin HTTP handler — wrap with `onRequest()` yourself if you
-     * didn't pass `onRequest` in the admin config.
-     * @example
-     * ```ts
-     * export const syncAdmin = onRequest(sync.adminHandler!);
-     * ```
-     */
-    adminHandler: ((req: any, res: any) => Promise<void>) | null;
-    /** Process a SyncEvent directly (for testing) */
-    handleMessage: (event: SyncEvent) => Promise<void>;
-    /** Internal queue map (for testing) */
-    queues: Map<string, SyncQueue>;
-    /** Flush all queues and stop timers */
-    shutdown: () => Promise<void>;
-};
-
-/**
- * Sync Admin — optional HTTP endpoint for inspecting and managing the
- * Firestore → SQL sync pipeline.
- *
- * Features (gated by `featuresFlag`):
- *  - **healthCheck** — compare expected Zod-derived columns vs actual SQL columns
- *  - **manualSync** — force re-sync all documents in a Firestore collection
- *  - **viewQueue** — inspect pending items in the per-repo SyncQueue
- *
- * @example
- * ```typescript
- * const sync = createFirestoreSync(repos, {
- *   // …deps, adapter, etc.
- *   admin: {
- *     auth: { type: "basic", username: "admin", password: "secret" },
- *     featuresFlag: { healthCheck: true, manualSync: true, viewQueue: true },
- *   },
- * });
+ * PubSub worker — creates a Cloud Function that receives {@link SyncEvent}
+ * messages from PubSub, routes them to per-repo {@link SyncQueue}s, and
+ * flushes batches to the configured {@link SqlAdapter}.
  *
- * export const syncAdmin = onRequest(sync.adminHandler!);
- * ```
+ * Dependencies (`firebase-functions`, `@google-cloud/pubsub`) are injected
+ * via the `deps` config property.
  */
 
 /**
- * Create the sync admin HTTP handler.
+ * Create a PubSub-triggered Cloud Function that syncs Firestore changes
+ * to a SQL database.
  *
- * @param repoMapping   - The configured repository mapping
- * @param adapter       - The SQL adapter (e.g. BigQueryAdapter)
- * @param queues        - Live queue map from the worker
- * @param handleMessage - Direct SyncEvent processor from the worker
- * @param config        - Admin-specific config (auth, basePath, features)
- * @param repoConfigs   - Per-repo sync config (tableName, exclude, columnMap…)
- * @param pubsub        - PubSub client (needed for configCheck)
- * @param topicPrefix   - PubSub topic prefix (needed for configCheck)
+ * Returns an object with:
+ * - `createHandler` — creates a Cloud Function for a PubSub topic
+ * - `handleMessage` — process a SyncEvent directly (for testing)
+ * - `queues` — internal SyncQueue map (for testing / manual flush)
+ * - `shutdown()` — flush all queues and stop timers
  */
-declare function createSyncAdminServer(repoMapping: Record<string, any>, adapter: SqlAdapter, queues: Map<string, SyncQueue>, handleMessage: (event: SyncEvent) => Promise<void>, config: SyncAdminConfig, repoConfigs: Record<string, RepoSyncConfig<string> | undefined>, pubsub?: PubSubClientDep, topicPrefix?: string): (req: any, res: any) => Promise<void>;
+declare function createSyncWorker<M extends Record<string, any>>(repoMapping: M, config: SyncWorkerConfig<NoInfer<M>>): {
+    /** Process a SyncEvent directly (for testing or custom PubSub integration). */
+    handleMessage: (syncEvent: SyncEvent) => Promise<void>;
+    /** Create a Cloud Function handler for a specific PubSub topic. */
+    createHandler: (topicName: string) => any;
+    /** Internal queue map (for testing). */
+    queues: Map<string, SyncQueue>;
+    /** Flush all queues and stop timers. */
+    shutdown(): Promise<void>;
+};
 
-export { FirestoreSyncConfig, GenerateDDLConfig, LogicalType, type MigrateResult, PubSubClientDep, RepoSyncConfig, SqlAdapter, SqlColumn, SqlDialect, SqlTableDef, SyncAdminConfig, SyncEvent, SyncQueue, type SyncQueueOptions, SyncTriggersConfig, SyncWorkerConfig, addColumnsDDL, autoMigrate, createFirestoreSync, createSyncAdminServer, createSyncTriggers, createSyncWorker, createTableDDL, generateDDL, serializeDocument, serializeValue, zodSchemaToColumns, zodTypeToLogical };
+export { FirestoreSyncConfig, GenerateDDLConfig, LogicalType, type MigrateResult, PubSubClientDep, RepoSyncConfig, SqlAdapter, SqlColumn, SqlDialect, SqlTableDef, SyncEvent, SyncQueue, type SyncQueueOptions, SyncTriggersConfig, SyncWorkerConfig, addColumnsDDL, adminsyncConfig, autoMigrate, createFirestoreSync, createSyncTriggers, createSyncWorker, createTableDDL, createadminsyncServer, generateDDL, serializeDocument, serializeValue, zodSchemaToColumns, zodTypeToLogical };