devmind 1.0.0

package/dist/database/extractors/firebase.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Firebase Firestore Schema Extractor
+ * Extracts database schema information from Firebase Firestore by sampling documents
+ */
+export interface FirebaseFieldInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    isArray: boolean;
+    isReference: boolean;
+    sampleValues?: any[];
+}
+export interface FirebaseCollectionInfo {
+    name: string;
+    documentCount: number;
+    fields: FirebaseFieldInfo[];
+    sampleSize: number;
+}
+export interface FirebaseSchemaInfo {
+    collections: FirebaseCollectionInfo[];
+    databaseType: 'firebase';
+    projectId: string;
+}
+export declare class FirebaseExtractor {
+    private projectId;
+    private serviceAccountPath?;
+    private db;
+    private sampleSize;
+    private app;
+    constructor(projectId: string, serviceAccountPath?: string, sampleSize?: number);
+    extract(): Promise<FirebaseSchemaInfo>;
+    private extractCollectionSchema;
+    private inferSchemaFromDocuments;
+    private analyzeObject;
+    private isFirestoreReference;
+    private getFirestoreType;
+    private determinePrimaryType;
+    close(): Promise<void>;
+}

package/dist/database/extractors/firebase.js

@@ -0,0 +1,192 @@
+/**
+ * Firebase Firestore Schema Extractor
+ * Extracts database schema information from Firebase Firestore by sampling documents
+ */
+import * as admin from 'firebase-admin';
+export class FirebaseExtractor {
+    projectId;
+    serviceAccountPath;
+    db = null;
+    sampleSize = 100;
+    app = null;
+    constructor(projectId, serviceAccountPath, sampleSize = 100) {
+        this.projectId = projectId;
+        this.serviceAccountPath = serviceAccountPath;
+        this.sampleSize = sampleSize;
+    }
+    async extract() {
+        try {
+            // Initialize Firebase Admin
+            if (!this.serviceAccountPath && !process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+                throw new Error('Firebase service account required. Use --firebase-key or set GOOGLE_APPLICATION_CREDENTIALS env var.');
+            }
+            const config = {
+                projectId: this.projectId,
+            };
+            if (this.serviceAccountPath) {
+                const serviceAccount = await import(this.serviceAccountPath);
+                config.credential = admin.credential.cert(serviceAccount.default || serviceAccount);
+            }
+            this.app = admin.initializeApp(config, `cohere-${Date.now()}`);
+            this.db = admin.firestore(this.app);
+            // List all collections (top-level only for now)
+            const collections = await this.db.listCollections();
+            const collectionNames = collections.map((c) => c.id);
+            console.log(`   Found ${collectionNames.length} collections`);
+            // Extract schema for each collection
+            const collectionSchemas = await Promise.all(collectionNames.map((name) => this.extractCollectionSchema(name)));
+            return {
+                collections: collectionSchemas,
+                databaseType: 'firebase',
+                projectId: this.projectId,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async extractCollectionSchema(collectionName) {
+        if (!this.db)
+            throw new Error('Firestore not initialized');
+        const collectionRef = this.db.collection(collectionName);
+        // Get approximate count (note: Firestore doesn't have built-in count)
+        const snapshot = await collectionRef.limit(this.sampleSize).get();
+        const sampleSize = snapshot.size;
+        // Sample documents
+        const documents = snapshot.docs;
+        // Infer schema from sampled documents
+        const fields = this.inferSchemaFromDocuments(documents);
+        return {
+            name: collectionName,
+            documentCount: sampleSize, // Approximate, as Firestore doesn't expose exact counts easily
+            fields,
+            sampleSize,
+        };
+    }
+    inferSchemaFromDocuments(documents) {
+        if (documents.length === 0)
+            return [];
+        const fieldMap = new Map();
+        // Analyze all documents
+        for (const doc of documents) {
+            const data = doc.data();
+            if (data) {
+                this.analyzeObject(data, fieldMap, '');
+            }
+        }
+        // Convert to field info
+        const fields = [];
+        for (const [fieldName, info] of fieldMap.entries()) {
+            const types = Array.from(info.types);
+            const primaryType = this.determinePrimaryType(types);
+            fields.push({
+                name: fieldName,
+                type: primaryType,
+                nullable: info.nullCount > 0,
+                isArray: info.isArray,
+                isReference: info.isReference,
+                sampleValues: info.samples.slice(0, 3),
+            });
+        }
+        return fields.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    analyzeObject(obj, fieldMap, prefix) {
+        for (const [key, value] of Object.entries(obj)) {
+            const fieldName = prefix ? `${prefix}.${key}` : key;
+            if (!fieldMap.has(fieldName)) {
+                fieldMap.set(fieldName, {
+                    types: new Set(),
+                    nullCount: 0,
+                    isArray: false,
+                    isReference: false,
+                    samples: [],
+                });
+            }
+            const fieldInfo = fieldMap.get(fieldName);
+            if (value === null || value === undefined) {
+                fieldInfo.nullCount++;
+                fieldInfo.types.add('null');
+            }
+            else if (Array.isArray(value)) {
+                fieldInfo.isArray = true;
+                fieldInfo.types.add('Array');
+                if (value.length > 0) {
+                    const elementType = this.getFirestoreType(value[0]);
+                    fieldInfo.types.add(`Array<${elementType}>`);
+                }
+            }
+            else if (this.isFirestoreReference(value)) {
+                fieldInfo.isReference = true;
+                fieldInfo.types.add('Reference');
+            }
+            else if (typeof value === 'object') {
+                const firestoreType = this.getFirestoreType(value);
+                fieldInfo.types.add(firestoreType);
+                // Don't recurse into special Firestore types
+                if (firestoreType === 'Map') {
+                    this.analyzeObject(value, fieldMap, fieldName);
+                }
+            }
+            else {
+                const firestoreType = this.getFirestoreType(value);
+                fieldInfo.types.add(firestoreType);
+                // Store sample values
+                if (fieldInfo.samples.length < 3 && firestoreType !== 'null') {
+                    fieldInfo.samples.push(value);
+                }
+            }
+        }
+    }
+    isFirestoreReference(value) {
+        // Check if it's a Firestore DocumentReference
+        return value && typeof value === 'object' && '_path' in value && 'firestore' in value;
+    }
+    getFirestoreType(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        // Check for Firestore-specific types
+        if (this.isFirestoreReference(value))
+            return 'Reference';
+        if (value instanceof Date || (value && typeof value.toDate === 'function'))
+            return 'Timestamp';
+        if (value && value.constructor && value.constructor.name === 'GeoPoint')
+            return 'GeoPoint';
+        // Standard JavaScript types
+        if (Array.isArray(value))
+            return 'Array';
+        if (typeof value === 'string')
+            return 'String';
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? 'Number' : 'Number';
+        }
+        if (typeof value === 'boolean')
+            return 'Boolean';
+        if (typeof value === 'object')
+            return 'Map';
+        return 'Mixed';
+    }
+    determinePrimaryType(types) {
+        if (types.length === 0)
+            return 'Mixed';
+        if (types.length === 1)
+            return types[0];
+        // Filter out null
+        const nonNullTypes = types.filter((t) => t !== 'null');
+        if (nonNullTypes.length === 1)
+            return nonNullTypes[0];
+        if (nonNullTypes.length === 0)
+            return 'null';
+        // If multiple types, return Mixed
+        return `Mixed(${nonNullTypes.join('|')})`;
+    }
+    async close() {
+        if (this.app) {
+            await this.app.delete();
+            this.app = null;
+            this.db = null;
+        }
+    }
+}
+//# sourceMappingURL=firebase.js.map

package/dist/database/extractors/firebase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firebase.js","sourceRoot":"","sources":["../../../src/database/extractors/firebase.ts"],"names":[],"mappings":"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"}

package/dist/database/extractors/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Extractor Index
+ * Central export for all schema extractors and unified types
+ */
+import type { SchemaInfo as PostgresSchemaInfo } from './postgres.js';
+import type { MySQLSchemaInfo } from './mysql.js';
+import type { SQLiteSchemaInfo } from './sqlite.js';
+import type { PrismaSchemaInfo } from './prisma.js';
+import type { DrizzleSchemaInfo } from './drizzle.js';
+import type { MongoDBSchemaInfo } from './mongodb.js';
+import type { FirebaseSchemaInfo } from './firebase.js';
+export type { PostgresSchemaInfo, MySQLSchemaInfo, SQLiteSchemaInfo };
+export type { PrismaSchemaInfo, DrizzleSchemaInfo, MongoDBSchemaInfo, FirebaseSchemaInfo };
+export interface UnifiedColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    isPrimaryKey: boolean;
+    isUnique: boolean;
+    isForeignKey: boolean;
+    referencesTable?: string;
+    referencesColumn?: string;
+    onDelete?: string;
+    onUpdate?: string;
+    description?: string;
+}
+export interface UnifiedIndexInfo {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    isPrimaryKey: boolean;
+}
+export interface UnifiedRelationInfo {
+    fromTable: string;
+    fromColumn: string;
+    toTable: string;
+    toColumn: string;
+    cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
+    onDelete?: string;
+    onUpdate?: string;
+}
+export interface UnifiedTableInfo {
+    name: string;
+    description?: string;
+    columns: UnifiedColumnInfo[];
+    indexes: UnifiedIndexInfo[];
+    relations: UnifiedRelationInfo[];
+    primaryKey: string[];
+}
+export interface UnifiedSchemaInfo {
+    tables: UnifiedTableInfo[];
+    databaseType: 'postgresql' | 'mysql' | 'sqlite' | 'prisma' | 'drizzle' | 'mongodb' | 'firebase';
+    schemaName?: string;
+    source?: string;
+}
+export declare class UnifiedSchemaConverter {
+    static convert(schemaInfo: any): UnifiedSchemaInfo;
+}
+export type ExtractorType = 'postgresql' | 'mysql' | 'sqlite' | 'prisma' | 'drizzle' | 'mongodb' | 'firebase';
+export interface SchemaExtractor {
+    extract(): Promise<any>;
+    close(): Promise<void>;
+}
+export declare function createExtractor(type: ExtractorType, connectionString: string, options?: {
+    schemaPath?: string;
+    projectId?: string;
+    serviceAccountPath?: string;
+}): Promise<SchemaExtractor>;

package/dist/database/extractors/index.js

@@ -0,0 +1,345 @@
+/**
+ * Extractor Index
+ * Central export for all schema extractors and unified types
+ */
+// Converter Class
+export class UnifiedSchemaConverter {
+    static convert(schemaInfo) {
+        switch (schemaInfo.databaseType) {
+            case 'postgresql':
+                return convertPostgres(schemaInfo);
+            case 'mysql':
+                return convertMySQL(schemaInfo);
+            case 'sqlite':
+                return convertSQLite(schemaInfo);
+            case 'prisma':
+                return convertPrisma(schemaInfo);
+            case 'drizzle':
+                return convertDrizzle(schemaInfo);
+            case 'mongodb':
+                return convertMongoDB(schemaInfo);
+            case 'firebase':
+                return convertFirebase(schemaInfo);
+            default:
+                throw new Error(`Unsupported database type: ${schemaInfo.databaseType}`);
+        }
+    }
+}
+function convertPostgres(schema) {
+    const source = schema.schemaName ? `postgresql://${schema.schemaName}` : 'postgresql';
+    return {
+        tables: schema.tables.map((table) => convertTable(table, (table.foreignKeys || []).map((fk) => ({
+            ...fk,
+            onDelete: fk.onDelete || undefined,
+            onUpdate: fk.onUpdate || undefined,
+        })), table.indexes || [])),
+        databaseType: 'postgresql',
+        schemaName: schema.schemaName,
+        source,
+    };
+}
+function convertMySQL(schema) {
+    const source = schema.databaseName ? `mysql://${schema.databaseName}` : 'mysql';
+    return {
+        tables: schema.tables.map((table) => convertTable(table, (table.foreignKeys || []).map((fk) => ({
+            ...fk,
+            onDelete: fk.onDelete || undefined,
+            onUpdate: fk.onUpdate || undefined,
+        })), table.indexes || [])),
+        databaseType: 'mysql',
+        schemaName: schema.databaseName,
+        source,
+    };
+}
+function convertSQLite(schema) {
+    const source = schema.databasePath || 'sqlite';
+    return {
+        tables: schema.tables.map((table) => convertSQLiteTable(table)),
+        databaseType: 'sqlite',
+        source,
+    };
+}
+function convertPrisma(schema) {
+    const source = schema.generator?.output || 'prisma';
+    return {
+        tables: schema.tables.map((table) => ({
+            name: table.name,
+            description: table.description || undefined,
+            columns: table.columns.map((col) => ({
+                name: col.name,
+                type: col.type,
+                nullable: col.isOptional,
+                default: col.defaultValue,
+                isPrimaryKey: table.primaryKey.includes(col.name),
+                isUnique: col.isUnique,
+                isForeignKey: col.isRelation,
+                referencesTable: col.isRelation ? col.type : undefined,
+                referencesColumn: col.relationReferences?.[0],
+                onDelete: col.onDelete || undefined,
+                description: undefined,
+            })),
+            indexes: table.indexes.map((idx) => ({
+                name: idx.name,
+                columns: idx.columns,
+                unique: idx.unique,
+                isPrimaryKey: false,
+            })),
+            relations: table.relations.map((rel) => ({
+                fromTable: rel.fromTable,
+                fromColumn: rel.fromFields[0] || '',
+                toTable: rel.toTable,
+                toColumn: rel.toFields[0] || '',
+                cardinality: mapRelationCardinality(rel.type),
+                onDelete: rel.onDelete || undefined,
+            })),
+            primaryKey: table.primaryKey,
+        })),
+        databaseType: 'prisma',
+        schemaName: schema.generator?.output,
+        source,
+    };
+}
+function convertDrizzle(schema) {
+    const source = schema.dialect;
+    return {
+        tables: schema.tables.map((table) => ({
+            name: table.name,
+            description: table.description || undefined,
+            columns: table.columns.map((col) => ({
+                name: col.name,
+                type: col.type,
+                nullable: col.isOptional,
+                default: col.defaultValue,
+                isPrimaryKey: col.isPrimaryKey,
+                isUnique: col.isUnique,
+                isForeignKey: col.isRelation,
+                referencesTable: col.relationName || undefined,
+                referencesColumn: undefined,
+                onDelete: col.onDelete || undefined,
+                description: undefined,
+            })),
+            indexes: table.indexes.map((idx) => ({
+                name: idx.name,
+                columns: idx.columns,
+                unique: idx.unique,
+                isPrimaryKey: false,
+            })),
+            relations: table.relations.map((rel) => ({
+                fromTable: rel.fromTable,
+                fromColumn: rel.fromColumns[0] || '',
+                toTable: rel.toTable,
+                toColumn: rel.toColumns[0] || '',
+                cardinality: mapRelationCardinality(rel.type),
+                onDelete: rel.onDelete || undefined,
+            })),
+            primaryKey: table.primaryKey,
+        })),
+        databaseType: 'drizzle',
+        schemaName: schema.dialect,
+        source,
+    };
+}
+function convertMongoDB(schema) {
+    const source = schema.databaseName ? `mongodb://${schema.databaseName}` : 'mongodb';
+    return {
+        tables: schema.collections.map((collection) => ({
+            name: collection.name,
+            description: `MongoDB collection (${collection.documentCount} documents, sampled ${collection.sampleSize})`,
+            columns: collection.fields.map((field) => ({
+                name: field.name,
+                type: field.isArray ? `${field.type}[]` : field.type,
+                nullable: field.nullable,
+                default: null,
+                isPrimaryKey: field.name === '_id',
+                isUnique: field.name === '_id',
+                isForeignKey: field.type === 'ObjectId' && field.name !== '_id',
+                referencesTable: undefined, // MongoDB doesn't have explicit FK constraints
+                referencesColumn: undefined,
+                description: field.sampleValues && field.sampleValues.length > 0
+                    ? `Sample: ${JSON.stringify(field.sampleValues[0])}`
+                    : undefined,
+            })),
+            indexes: collection.indexes.map((idx) => ({
+                name: idx.name,
+                columns: Object.keys(idx.keys),
+                unique: idx.unique,
+                isPrimaryKey: idx.name === '_id_',
+            })),
+            relations: [], // MongoDB doesn't have explicit relationships
+            primaryKey: ['_id'],
+        })),
+        databaseType: 'mongodb',
+        schemaName: schema.databaseName,
+        source,
+    };
+}
+function convertFirebase(schema) {
+    const source = schema.projectId ? `firebase://${schema.projectId}` : 'firebase';
+    return {
+        tables: schema.collections.map((collection) => ({
+            name: collection.name,
+            description: `Firestore collection (${collection.documentCount} documents sampled)`,
+            columns: collection.fields.map((field) => ({
+                name: field.name,
+                type: field.isArray ? `${field.type}[]` : field.type,
+                nullable: field.nullable,
+                default: null,
+                isPrimaryKey: field.name === 'id' || field.name === '_id',
+                isUnique: field.name === 'id' || field.name === '_id',
+                isForeignKey: field.isReference,
+                referencesTable: undefined,
+                referencesColumn: undefined,
+                description: field.sampleValues && field.sampleValues.length > 0
+                    ? `Sample: ${JSON.stringify(field.sampleValues[0])}`
+                    : undefined,
+            })),
+            indexes: [],
+            relations: [],
+            primaryKey: ['id'],
+        })),
+        databaseType: 'firebase',
+        schemaName: schema.projectId,
+        source,
+    };
+}
+function convertTable(table, foreignKeys, indexes) {
+    const primaryKeySet = new Set(table.primaryKey || []);
+    const uniqueColumns = new Set();
+    indexes.forEach((idx) => {
+        if (idx.unique) {
+            idx.columns.forEach((column) => uniqueColumns.add(column));
+        }
+    });
+    const fkMap = new Map();
+    foreignKeys.forEach((fk) => fkMap.set(fk.column, fk));
+    return {
+        name: table.name,
+        description: table.description || table.comment,
+        columns: (table.columns || []).map((col) => {
+            const fk = fkMap.get(col.name);
+            return {
+                name: col.name,
+                type: col.type,
+                nullable: col.nullable,
+                default: col.default || col.defaultValue || null,
+                isPrimaryKey: primaryKeySet.has(col.name),
+                isUnique: uniqueColumns.has(col.name),
+                isForeignKey: Boolean(fk),
+                referencesTable: fk?.referencesTable,
+                referencesColumn: fk?.referencesColumn,
+                onDelete: fk?.onDelete,
+                onUpdate: fk?.onUpdate,
+                description: col.description || col.comment || undefined,
+            };
+        }),
+        indexes: indexes.map((idx) => ({
+            name: idx.name,
+            columns: idx.columns || [],
+            unique: idx.unique,
+            isPrimaryKey: Boolean(idx.isPrimaryKey),
+        })),
+        relations: foreignKeys.map((fk) => ({
+            fromTable: table.name,
+            fromColumn: fk.column,
+            toTable: fk.referencesTable,
+            toColumn: fk.referencesColumn,
+            cardinality: 'N:1',
+            onDelete: fk.onDelete,
+            onUpdate: fk.onUpdate,
+        })),
+        primaryKey: table.primaryKey || [],
+    };
+}
+function convertSQLiteTable(table) {
+    const primaryKeySet = new Set(table.primaryKey || []);
+    const uniqueColumns = new Set();
+    table.indexes?.forEach((idx) => {
+        if (idx.unique) {
+            idx.columns.forEach((column) => uniqueColumns.add(column));
+        }
+    });
+    const fkMap = new Map();
+    table.foreignKeys?.forEach((fk) => fkMap.set(fk.from, fk));
+    return {
+        name: table.name,
+        description: undefined,
+        columns: (table.columns || []).map((col) => {
+            const fk = fkMap.get(col.name);
+            return {
+                name: col.name,
+                type: col.type,
+                nullable: col.nullable,
+                default: col.default || null,
+                isPrimaryKey: primaryKeySet.has(col.name),
+                isUnique: uniqueColumns.has(col.name),
+                isForeignKey: Boolean(fk),
+                referencesTable: fk?.table,
+                referencesColumn: fk?.to,
+                onDelete: fk?.onDelete,
+                onUpdate: fk?.onUpdate,
+                description: undefined,
+            };
+        }),
+        indexes: (table.indexes || []).map((idx) => ({
+            name: idx.name,
+            columns: idx.columns,
+            unique: idx.unique,
+            isPrimaryKey: idx.isPrimaryKey,
+        })),
+        relations: (table.foreignKeys || []).map((fk) => ({
+            fromTable: table.name,
+            fromColumn: fk.from,
+            toTable: fk.table,
+            toColumn: fk.to,
+            cardinality: 'N:1',
+            onDelete: fk.onDelete,
+            onUpdate: fk.onUpdate,
+        })),
+        primaryKey: table.primaryKey || [],
+    };
+}
+function mapRelationCardinality(type) {
+    switch (type) {
+        case 'one-to-one':
+        case '1:1':
+            return '1:1';
+        case 'one-to-many':
+            return '1:N';
+        case 'many-to-one':
+            return 'N:1';
+        case 'many-to-many':
+            return 'N:M';
+        default:
+            return '1:N';
+    }
+}
+export async function createExtractor(type, connectionString, options) {
+    switch (type) {
+        case 'postgresql':
+            const { PostgresExtractor } = await import('./postgres.js');
+            return new PostgresExtractor(connectionString);
+        case 'mysql':
+            const { MySQLExtractor } = await import('./mysql.js');
+            return new MySQLExtractor(connectionString);
+        case 'sqlite':
+            const { SQLiteExtractor } = await import('./sqlite.js');
+            return new SQLiteExtractor(connectionString);
+        case 'prisma':
+            const { PrismaExtractor } = await import('./prisma.js');
+            return new PrismaExtractor(options?.schemaPath || 'prisma/schema.prisma');
+        case 'drizzle':
+            const { DrizzleExtractor } = await import('./drizzle.js');
+            return new DrizzleExtractor(options?.schemaPath || 'src/db/schema.ts');
+        case 'mongodb':
+            const { MongoDBExtractor } = await import('./mongodb.js');
+            return new MongoDBExtractor(connectionString);
+        case 'firebase':
+            const { FirebaseExtractor } = await import('./firebase.js');
+            const projectId = options?.projectId || 'unknown';
+            const serviceAccountPath = options?.serviceAccountPath;
+            return new FirebaseExtractor(projectId, serviceAccountPath);
+        default:
+            throw new Error(`Unknown extractor type: ${type}`);
+    }
+}
+//# sourceMappingURL=index.js.map