@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.5584634

package/dist/server-postgresql/src/PostgresBackendDriver.d.ts

@@ -33,17 +33,19 @@ export declare class PostgresBackendDriver implements DataDriver {
     constructor(db: DrizzleClient, realtimeService: RealtimeService, registry: PostgresCollectionRegistry, user?: User, poolManager?: DatabasePoolManager | undefined, historyService?: HistoryService);
     /**
      * Typed admin capabilities (SQLAdmin + SchemaAdmin + BranchAdmin).
+     * Implemented as a getter so method references are resolved at call-time,
+     * allowing test spies applied after construction to take effect.
      */
-    admin: DatabaseAdmin;
+    get admin(): DatabaseAdmin;
     private resolveCollectionCallbacks;
-    fetchCollection<M extends Record<string, any>>({ path, collection, filter, limit, startAfter, orderBy, searchString, order }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
-    listenCollection<M extends Record<string, any>>({ path, collection, filter, limit, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
-    fetchEntity<M extends Record<string, any>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    listenEntity<M extends Record<string, any>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
-    saveEntity<M extends Record<string, any>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
-    deleteEntity<M extends Record<string, any>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
+    fetchCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    listenCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
+    fetchEntity<M extends Record<string, unknown>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    listenEntity<M extends Record<string, unknown>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
+    saveEntity<M extends Record<string, unknown>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
-    countEntities<M extends Record<string, any>>({ path, collection, filter }: FetchCollectionProps<M>): Promise<number>;
+    countEntities<M extends Record<string, unknown>>({ path, collection, filter, searchString }: FetchCollectionProps<M>): Promise<number>;
     private getTargetDb;
     executeSql(sqlText: string, options?: {
         database?: string;
@@ -82,31 +84,17 @@ export declare class AuthenticatedPostgresBackendDriver implements DataDriver {
      */
     admin: DatabaseAdmin;
     private withTransaction;
-    fetchCollection<M extends Record<string, any>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
     /**
      * Injects the authenticated user's context into the most recently
      * registered realtime subscription so RLS-aware polling can apply.
      */
     private injectAuthContext;
-    listenCollection<M extends Record<string, any>>(props: ListenCollectionProps<M>): () => void;
-    fetchEntity<M extends Record<string, any>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    listenEntity<M extends Record<string, any>>(props: ListenEntityProps<M>): () => void;
-    saveEntity<M extends Record<string, any>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
-    deleteEntity<M extends Record<string, any>>(props: DeleteEntityProps<M>): Promise<void>;
+    listenCollection<M extends Record<string, unknown>>(props: ListenCollectionProps<M>): () => void;
+    fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void;
+    saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
-    countEntities<M extends Record<string, any>>(props: FetchCollectionProps<M>): Promise<number>;
-    /**
-     * Intentionally delegates to the base delegate WITHOUT RLS wrapping.
-     * executeSql is an admin-only feature; access control should be enforced
-     * at the API route level, not via database-level RLS.
-     */
-    executeSql(sqlText: string, options?: {
-        database?: string;
-        role?: string;
-    }): Promise<Record<string, unknown>[]>;
-    fetchAvailableDatabases(): Promise<string[]>;
-    fetchAvailableRoles(): Promise<string[]>;
-    fetchCurrentDatabase(): Promise<string | undefined>;
-    fetchUnmappedTables(mappedPaths?: string[]): Promise<string[]>;
-    fetchTableMetadata(tableName: string): Promise<TableMetadata>;
+    countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
 }

package/dist/server-postgresql/src/auth/services.d.ts

@@ -1,6 +1,6 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { User, NewUser } from "../schema/auth-schema";
-import { UserRepository, RoleRepository, TokenRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, ListUsersOptions, PaginatedUsersResult, RoleData as Role } from "@rebasepro/server-core";
+import { UserRepository, RoleRepository, TokenRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, UserIdentityData, ListUsersOptions, PaginatedUsersResult, RoleData as Role } from "@rebasepro/server-core";
 export type { Role };
 /**
  * PostgreSQL implementation of UserRepository.
@@ -12,7 +12,9 @@ export declare class UserService implements UserRepository {
     createUser(data: NewUser): Promise<User>;
     getUserById(id: string): Promise<User | null>;
     getUserByEmail(email: string): Promise<User | null>;
-    getUserByGoogleId(googleId: string): Promise<User | null>;
+    getUserByIdentity(provider: string, providerId: string): Promise<User | null>;
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
     updateUser(id: string, data: Partial<Omit<NewUser, "id">>): Promise<User | null>;
     deleteUser(id: string): Promise<void>;
     listUsers(): Promise<User[]>;
@@ -148,7 +150,9 @@ export declare class PostgresAuthRepository implements AuthRepository {
     createUser(data: CreateUserData): Promise<UserData>;
     getUserById(id: string): Promise<UserData | null>;
     getUserByEmail(email: string): Promise<UserData | null>;
-    getUserByGoogleId(googleId: string): Promise<UserData | null>;
+    getUserByIdentity(provider: string, providerId: string): Promise<UserData | null>;
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
     updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null>;
     deleteUser(id: string): Promise<void>;
     listUsers(): Promise<UserData[]>;

package/dist/server-postgresql/src/collections/PostgresCollectionRegistry.d.ts

@@ -1,5 +1,5 @@
 import { CollectionRegistry } from "@rebasepro/common";
-import type { EntityCollection } from "@rebasepro/types";
+import { type EntityCollection } from "@rebasepro/types";
 import { PgEnum, PgTable } from "drizzle-orm/pg-core";
 import { Relations } from "drizzle-orm";
 import { CollectionRegistryInterface } from "../interfaces";

package/dist/server-postgresql/src/connection.d.ts

@@ -1,7 +1,40 @@
 import { Pool } from "pg";
-export declare function createPostgresDatabaseConnection(connectionString: string, schema?: Record<string, unknown>): {
+/**
+ * Configuration for the Postgres connection pool.
+ *
+ * Sensible defaults are provided for production Cloud Run / single-instance
+ * deployments. Override via environment variables or explicit config.
+ */
+export interface PostgresPoolConfig {
+    /** Maximum number of connections in the pool (default: 20) */
+    max?: number;
+    /** Close idle connections after this many ms (default: 30 000) */
+    idleTimeoutMillis?: number;
+    /** Abort connection attempts after this many ms (default: 10 000) */
+    connectionTimeoutMillis?: number;
+    /** Per-query timeout in ms (default: 30 000) */
+    queryTimeout?: number;
+    /** Per-statement timeout in ms (default: 30 000) */
+    statementTimeout?: number;
+    /** Enable TCP keep-alive (default: true) */
+    keepAlive?: boolean;
+}
+/**
+ * Create a Drizzle-backed Postgres connection with a production-grade
+ * connection pool.
+ *
+ * @param connectionString  Postgres connection URL
+ * @param schema            Optional Drizzle schema for the relational API
+ * @param poolConfig        Optional pool tuning (merged over defaults)
+ *
+ * @returns `{ db, pool, connectionString }` — the `pool` is exposed so
+ *          callers can register shutdown hooks (`pool.end()`) or monitor
+ *          pool metrics.
+ */
+export declare function createPostgresDatabaseConnection(connectionString: string, schema?: Record<string, unknown>, poolConfig?: PostgresPoolConfig): {
     db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
         $client: Pool;
     };
+    pool: Pool;
     connectionString: string;
 };

package/dist/server-postgresql/src/data-transformer.d.ts

@@ -1,9 +1,31 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { EntityCollection, Properties, Property } from "@rebasepro/types";
+import { EntityCollection, Properties, Property, Relation } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 /**
  * Data transformation utilities for converting between frontend and database formats.
  */
+/**
+ * Typed result from `serializeDataToServer`.
+ * Replaces the hidden `__inverseRelationUpdates` / `__joinPathRelationUpdates`
+ * dunder-property mutation pattern with explicit, typed state management.
+ */
+export interface SerializedEntityData {
+    /** Scalar column values ready for INSERT/UPDATE. */
+    scalarData: Record<string, unknown>;
+    /** Inverse relation updates that must be applied to target tables. */
+    inverseRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newValue: unknown;
+        currentEntityId?: string | number;
+    }>;
+    /** JoinPath relation updates that require multi-hop writes. */
+    joinPathRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newTargetId: string | number | null;
+    }>;
+}
 /**
  * Helper function to sanitize and convert dates to ISO strings
  */
@@ -11,7 +33,7 @@ export declare function sanitizeAndConvertDates(obj: unknown): unknown;
 /**
  * Transform relations for database storage (relation objects to IDs)
  */
-export declare function serializeDataToServer<M extends Record<string, any>>(entity: M, properties: Properties, collection?: EntityCollection, registry?: PostgresCollectionRegistry): Record<string, unknown>;
+export declare function serializeDataToServer<M extends Record<string, unknown>>(entity: M, properties: Properties, collection?: EntityCollection, registry?: PostgresCollectionRegistry): SerializedEntityData;
 /**
  * Serialize a single property value for database storage
  */
@@ -19,7 +41,7 @@ export declare function serializePropertyToServer(value: unknown, property: Prop
 /**
  * Transform IDs back to relation objects for frontend
  */
-export declare function parseDataFromServer<M extends Record<string, any>>(data: M, collection: EntityCollection, db?: NodePgDatabase<any>, registry?: PostgresCollectionRegistry): Promise<M>;
+export declare function parseDataFromServer<M extends Record<string, unknown>>(data: M, collection: EntityCollection, db?: NodePgDatabase<Record<string, unknown>>, registry?: PostgresCollectionRegistry): Promise<M>;
 /**
  * Parse a single property value from database format to frontend format
  */
@@ -33,4 +55,4 @@ export declare function parsePropertyFromServer(value: unknown, property: Proper
  * Use this instead of `parseDataFromServer` when processing results from
  * `db.query.findFirst/findMany` which return pre-hydrated relation data.
  */
-export declare function normalizeDbValues<M extends Record<string, any>>(data: M, collection: EntityCollection): M;
+export declare function normalizeDbValues<M extends Record<string, unknown>>(data: M, collection: EntityCollection): M;

package/dist/server-postgresql/src/databasePoolManager.d.ts

@@ -1,5 +1,5 @@
-import { Pool } from 'pg';
-import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { Pool } from "pg";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
 export declare class DatabasePoolManager {
     private pools;
     private drizzleInstances;

package/dist/server-postgresql/src/schema/auth-schema.d.ts

@@ -103,44 +103,6 @@ export declare const users: import("drizzle-orm/pg-core").PgTableWithColumns<{
         }, {}, {
             length: 500;
         }>;
-        provider: import("drizzle-orm/pg-core").PgColumn<{
-            name: "provider";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 50;
-        }>;
-        googleId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "google_id";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 255;
-        }>;
         emailVerified: import("drizzle-orm/pg-core").PgColumn<{
             name: "email_verified";
             tableName: "users";
@@ -739,10 +701,144 @@ export declare const appConfig: import("drizzle-orm/pg-core").PgTableWithColumns
     };
     dialect: "pg";
 }>;
+/**
+ * User identities - maps external OAuth profiles back to local users
+ */
+export declare const userIdentities: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "user_identities";
+    schema: "rebase";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 50;
+        }>;
+        providerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_id";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        profileData: import("drizzle-orm/pg-core").PgColumn<{
+            name: "profile_data";
+            tableName: "user_identities";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "user_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "user_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export declare const usersRelations: import("drizzle-orm").Relations<"users", {
     userRoles: import("drizzle-orm").Many<"user_roles">;
     refreshTokens: import("drizzle-orm").Many<"refresh_tokens">;
     passwordResetTokens: import("drizzle-orm").Many<"password_reset_tokens">;
+    userIdentities: import("drizzle-orm").Many<"user_identities">;
 }>;
 export declare const rolesRelations: import("drizzle-orm").Relations<"roles", {
     userRoles: import("drizzle-orm").Many<"user_roles">;
@@ -757,6 +853,9 @@ export declare const refreshTokensRelations: import("drizzle-orm").Relations<"re
 export declare const passwordResetTokensRelations: import("drizzle-orm").Relations<"password_reset_tokens", {
     user: import("drizzle-orm").One<"users", true>;
 }>;
+export declare const userIdentitiesRelations: import("drizzle-orm").Relations<"user_identities", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
 export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;
 export type Role = typeof roles.$inferSelect;
@@ -765,3 +864,5 @@ export type UserRole = typeof userRoles.$inferSelect;
 export type RefreshToken = typeof refreshTokens.$inferSelect;
 export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
 export type AppConfig = typeof appConfig.$inferSelect;
+export type UserIdentity = typeof userIdentities.$inferSelect;
+export type NewUserIdentity = typeof userIdentities.$inferInsert;

package/dist/server-postgresql/src/schema/doctor-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server-postgresql/src/schema/doctor.d.ts

@@ -0,0 +1,43 @@
+import { EntityCollection, Property } from "@rebasepro/types";
+export type IssueSeverity = "error" | "warning" | "info";
+export interface DoctorIssue {
+    severity: IssueSeverity;
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key";
+    table?: string;
+    column?: string;
+    expected?: string;
+    actual?: string;
+    message: string;
+    fix: string;
+}
+export interface DoctorReport {
+    collectionsToSchema: {
+        passed: boolean;
+        issues: DoctorIssue[];
+    };
+    schemaToDatabase: {
+        passed: boolean;
+        issues: DoctorIssue[];
+    };
+    summary: {
+        passed: number;
+        warnings: number;
+        errors: number;
+    };
+}
+export declare function getExpectedColumnType(prop: Property): string | null;
+export declare function loadCollections(collectionsPath: string): Promise<EntityCollection[]>;
+export declare function checkCollectionsVsSchema(collections: EntityCollection[], schemaFilePath: string): Promise<{
+    passed: boolean;
+    issues: DoctorIssue[];
+}>;
+export declare function checkCollectionsVsDatabase(collections: EntityCollection[], databaseUrl: string): Promise<{
+    passed: boolean;
+    issues: DoctorIssue[];
+}>;
+export declare function renderReport(report: DoctorReport): void;
+export declare function runDoctor(options: {
+    collectionsPath: string;
+    schemaPath: string;
+    databaseUrl?: string;
+}): Promise<DoctorReport>;

package/dist/server-postgresql/src/schema/generate-drizzle-schema-logic.d.ts

@@ -1,2 +1,2 @@
 import { EntityCollection } from "@rebasepro/types";
-export declare const generateSchema: (collections: EntityCollection[]) => Promise<string>;
+export declare const generateSchema: (collections: EntityCollection[], stripPolicies?: boolean) => Promise<string>;

package/dist/server-postgresql/src/schema/introspect-db-logic.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Introspection logic — pure functions and the pipeline that transforms
+ * raw PostgreSQL metadata into Rebase collection definition files.
+ *
+ * This module contains NO side-effects: no fs writes, no pg.Client creation,
+ * no process.exit.  It is imported by introspect-db.ts (the CLI entry-point)
+ * and consumed directly by tests.
+ */
+export interface TableRow {
+    table_name: string;
+}
+export interface TableColumn {
+    table_name: string;
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    is_nullable: string;
+    column_default: string | null;
+}
+export interface EnumValue {
+    enum_name: string;
+    enum_value: string;
+    sort_order: number;
+}
+export interface PrimaryKeyRow {
+    table_name: string;
+    column_name: string;
+}
+export interface ForeignKeyRow {
+    table_name: string;
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+export interface TableMeta {
+    name: string;
+    columns: TableColumn[];
+    pks: string[];
+    fks: ForeignKeyRow[];
+}
+export declare function singularize(word: string): string;
+/**
+ * Convert a snake_case name to a human-readable Title Case label.
+ * e.g. "created_at" -> "Created At", "customer_id" -> "Customer Id"
+ */
+export declare function humanize(snakeName: string): string;
+/**
+ * Convert a snake_case table name to a camelCase + "Collection" variable name.
+ * e.g. "company_token" -> "companyTokenCollection"
+ */
+export declare function toCollectionVarName(tableName: string): string;
+export declare function getIconForTable(tableName: string): string;
+/**
+ * Map a PostgreSQL data type to a Rebase property type.
+ */
+export declare function mapPgType(dataType: string): string;
+export declare function buildEnumMap(enumValues: EnumValue[]): Map<string, string[]>;
+export declare function buildTablesMap(tables: TableRow[], columns: TableColumn[], pks: PrimaryKeyRow[], fks: ForeignKeyRow[]): Map<string, TableMeta>;
+export declare function identifyJoinTables(tablesMap: Map<string, TableMeta>): Set<string>;
+export interface GeneratedFile {
+    tableName: string;
+    fileName: string;
+    content: string;
+}
+/**
+ * Generate the full TypeScript file content for a single collection.
+ * Pure function — no I/O.
+ */
+export declare function generateCollectionFile(tableName: string, meta: TableMeta, allFks: ForeignKeyRow[], joinTables: Set<string>, tablesMap: Map<string, TableMeta>, enumMap: Map<string, string[]>): string;
+/**
+ * Generate the content for an index.ts file that re-exports all collections.
+ */
+export declare function generateIndexContent(fileNames: string[]): string;
+/**
+ * Merge new exports into existing index.ts content.
+ * Returns the merged content string.
+ */
+export declare function mergeIndexContent(existingContent: string, newFileNames: string[]): string;
+/**
+ * Safely extract the host portion of a database URL for logging.
+ */
+export declare function safeHostFromUrl(url: string): string;

package/dist/server-postgresql/src/schema/introspect-db.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server-postgresql/src/schema/test-schema.d.ts

@@ -0,0 +1,24 @@
+export declare const testTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "test";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "test";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;