@gokiteam/goki-dev 0.2.0

package/src/api/firestore/Logic.js

@@ -0,0 +1,474 @@
+import { initializeApp, getApps, deleteApp } from 'firebase-admin/app'
+import { getFirestore } from 'firebase-admin/firestore'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import { Application } from '../../configs/Application.js'
+import { FIRESTORE_METADATA } from '../../db/Tables.js'
+
+const FIRESTORE_API = `http://${Application.firestore.emulatorHost}`
+const DEFAULT_PROJECT_ID = Application.firestore.projectId
+const DATABASE = '(default)'
+
+// Set emulator host environment variable for Firebase Admin SDK
+process.env.FIRESTORE_EMULATOR_HOST = Application.firestore.emulatorHost
+
+// Cache Firebase app instances by projectId
+const appCache = new Map()
+
+function getFirestoreDb (projectId) {
+  const pid = projectId || DEFAULT_PROJECT_ID
+  if (appCache.has(pid)) {
+    return appCache.get(pid)
+  }
+  const appName = `firestore-${pid}`
+  const existingApp = getApps().find(a => a.name === appName)
+  const app = existingApp || initializeApp({ projectId: pid }, appName)
+  const db = getFirestore(app)
+  appCache.set(pid, db)
+  return db
+}
+
+function resolveProjectId (params) {
+  return params.projectId || DEFAULT_PROJECT_ID
+}
+
+export const Logic = {
+  listProjects (params) {
+    const { traceId } = params
+    const projectIds = Application.firestore.projectIds
+    return {
+      projects: projectIds,
+      defaultProjectId: DEFAULT_PROJECT_ID,
+      total: projectIds.length,
+      traceId
+    }
+  },
+
+  async listCollections (params) {
+    const { traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const db = getFirestoreDb(projectId)
+      const collectionsSnapshot = await db.listCollections()
+      const collections = collectionsSnapshot
+        .map(col => col.id)
+        .filter(name => !name.startsWith('_'))
+        .sort()
+      return {
+        collections,
+        total: collections.length,
+        traceId
+      }
+    } catch (error) {
+      try {
+        const tracked = SqliteStore.list(FIRESTORE_METADATA)
+        const collections = tracked.data
+          .filter(row => row.collectionName)
+          .map(row => row.collectionName)
+          .sort()
+        return {
+          collections,
+          total: collections.length,
+          traceId
+        }
+      } catch (fallbackError) {
+        return {
+          status: 'error',
+          message: error.message,
+          traceId
+        }
+      }
+    }
+  },
+
+  async listDocuments (params) {
+    const { collectionPath, page = {}, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const pageSize = page.limit || 50
+      const pageToken = page.offset ? btoa(String(page.offset)) : undefined
+      const url = new URL(`${FIRESTORE_API}/v1/projects/${projectId}/databases/${DATABASE}/documents/${collectionPath}`)
+      url.searchParams.set('pageSize', pageSize)
+      if (pageToken) url.searchParams.set('pageToken', pageToken)
+      const response = await fetch(url)
+      if (!response.ok) {
+        if (response.status === 404) {
+          return { documents: [], total: 0, traceId }
+        }
+        throw new Error(`Firestore API error: ${response.statusText}`)
+      }
+      const data = await response.json()
+      return {
+        documents: data.documents || [],
+        total: (data.documents || []).length,
+        nextPageToken: data.nextPageToken,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async getDocument (params) {
+    const { collectionPath, documentId, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const response = await fetch(`${FIRESTORE_API}/v1/projects/${projectId}/databases/${DATABASE}/documents/${collectionPath}/${documentId}`)
+      if (!response.ok) {
+        throw new Error(`Firestore API error: ${response.statusText}`)
+      }
+      const document = await response.json()
+      return {
+        document,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async createDocument (params) {
+    const { collectionPath, documentId, fields, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const url = new URL(`${FIRESTORE_API}/v1/projects/${projectId}/databases/${DATABASE}/documents/${collectionPath}`)
+      if (documentId) {
+        url.searchParams.set('documentId', documentId)
+      }
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fields })
+      })
+      if (!response.ok) {
+        throw new Error(`Firestore API error: ${response.statusText}`)
+      }
+      const document = await response.json()
+      trackCollection(collectionPath)
+      return {
+        document,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async updateDocument (params) {
+    const { collectionPath, documentId, fields, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const response = await fetch(`${FIRESTORE_API}/v1/projects/${projectId}/databases/${DATABASE}/documents/${collectionPath}/${documentId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fields })
+      })
+      if (!response.ok) {
+        throw new Error(`Firestore API error: ${response.statusText}`)
+      }
+      const document = await response.json()
+      return {
+        document,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async deleteDocument (params) {
+    const { collectionPath, documentId, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const response = await fetch(`${FIRESTORE_API}/v1/projects/${projectId}/databases/${DATABASE}/documents/${collectionPath}/${documentId}`, {
+        method: 'DELETE'
+      })
+      if (!response.ok) {
+        throw new Error(`Firestore API error: ${response.statusText}`)
+      }
+      return {
+        success: true,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async deleteByQuery (params) {
+    const { collectionPath, where, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const queryResult = await this.executeQuery({
+        collectionPath,
+        where: where ? [where] : [],
+        limit: 10000,
+        projectId,
+        traceId
+      })
+      if (queryResult.status === 'error') {
+        return queryResult
+      }
+      const documents = queryResult.documents || []
+      const deletePromises = documents.map(doc => {
+        const docId = doc.name.split('/').pop()
+        return this.deleteDocument({ collectionPath, projectId, documentId: docId, traceId })
+      })
+      await Promise.all(deletePromises)
+      return {
+        success: true,
+        deletedCount: documents.length,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async deleteByPrefix (params) {
+    const { collectionPath, prefix, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const listResult = await this.listDocuments({
+        collectionPath,
+        projectId,
+        page: { limit: 10000 },
+        traceId
+      })
+      if (listResult.status === 'error') {
+        return listResult
+      }
+      const documents = listResult.documents || []
+      const matchingDocs = documents.filter(doc => {
+        const docId = doc.name.split('/').pop()
+        return docId.startsWith(prefix)
+      })
+      const deletePromises = matchingDocs.map(doc => {
+        const docId = doc.name.split('/').pop()
+        return this.deleteDocument({ collectionPath, projectId, documentId: docId, traceId })
+      })
+      await Promise.all(deletePromises)
+      return {
+        success: true,
+        deletedCount: matchingDocs.length,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async deleteBatch (params) {
+    const { collectionPath, documentIds = [], traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const results = await Promise.allSettled(
+        documentIds.map(docId =>
+          this.deleteDocument({ collectionPath, projectId, documentId: docId, traceId })
+        )
+      )
+      const succeeded = results.filter(r => r.status === 'fulfilled').length
+      const failedIds = documentIds.filter((_, idx) => results[idx].status === 'rejected')
+      return {
+        success: true,
+        deletedCount: succeeded,
+        failedIds,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async executeQuery (params) {
+    const { collectionPath, where = [], orderBy, limit = 50, traceId } = params
+    const projectId = resolveProjectId(params)
+    try {
+      const structuredQuery = {
+        from: [{ collectionId: collectionPath }]
+      }
+      if (where.length > 0) {
+        structuredQuery.where = buildWhereFilter(where)
+      }
+      if (orderBy) {
+        structuredQuery.orderBy = [{
+          field: { fieldPath: orderBy.field },
+          direction: orderBy.direction || 'ASCENDING'
+        }]
+      }
+      if (limit) {
+        structuredQuery.limit = limit
+      }
+      const response = await fetch(`${FIRESTORE_API}/v1/projects/${projectId}/databases/${DATABASE}/documents:runQuery`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ structuredQuery })
+      })
+      if (!response.ok) {
+        throw new Error(`Firestore API error: ${response.statusText}`)
+      }
+      const results = await response.json()
+      const documents = results.filter(r => r.document).map(r => r.document)
+      return {
+        documents,
+        total: documents.length,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async clearCollection (params) {
+    const { collectionPath, projectId, traceId } = params
+    try {
+      const listResult = await this.listDocuments({ collectionPath, projectId, page: { limit: 1000 }, traceId })
+      if (listResult.status === 'error') {
+        return listResult
+      }
+      const documents = listResult.documents || []
+      const deletePromises = documents.map(doc => {
+        const docId = doc.name.split('/').pop()
+        return this.deleteDocument({ collectionPath, projectId, documentId: docId, traceId })
+      })
+      await Promise.all(deletePromises)
+      untrackCollection(collectionPath)
+      return {
+        success: true,
+        deletedCount: documents.length,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  }
+}
+
+function buildWhereFilter (whereClauses) {
+  if (whereClauses.length === 1) {
+    return {
+      fieldFilter: {
+        field: { fieldPath: whereClauses[0].field },
+        op: mapOperator(whereClauses[0].operator),
+        value: convertValue(whereClauses[0].value)
+      }
+    }
+  }
+  return {
+    compositeFilter: {
+      op: 'AND',
+      filters: whereClauses.map(clause => ({
+        fieldFilter: {
+          field: { fieldPath: clause.field },
+          op: mapOperator(clause.operator),
+          value: convertValue(clause.value)
+        }
+      }))
+    }
+  }
+}
+
+function mapOperator (op) {
+  const opMap = {
+    '==': 'EQUAL',
+    '<': 'LESS_THAN',
+    '<=': 'LESS_THAN_OR_EQUAL',
+    '>': 'GREATER_THAN',
+    '>=': 'GREATER_THAN_OR_EQUAL',
+    '!=': 'NOT_EQUAL',
+    'array-contains': 'ARRAY_CONTAINS',
+    in: 'IN',
+    'array-contains-any': 'ARRAY_CONTAINS_ANY'
+  }
+  return opMap[op] || 'EQUAL'
+}
+
+function convertValue (value) {
+  if (typeof value === 'string') {
+    return { stringValue: value }
+  }
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) {
+      return { integerValue: String(value) }
+    }
+    return { doubleValue: value }
+  }
+  if (typeof value === 'boolean') {
+    return { booleanValue: value }
+  }
+  if (value === null) {
+    return { nullValue: null }
+  }
+  return { stringValue: String(value) }
+}
+
+function trackCollection (collectionPath) {
+  try {
+    const existing = SqliteStore.findOne(FIRESTORE_METADATA, { collectionName: collectionPath })
+    if (!existing) {
+      SqliteStore.create(FIRESTORE_METADATA, {
+        collectionName: collectionPath,
+        documentCount: 1,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      })
+    } else {
+      SqliteStore.update(FIRESTORE_METADATA, existing._id, {
+        documentCount: (existing.documentCount || 0) + 1,
+        updatedAt: Date.now()
+      })
+    }
+  } catch (error) {
+    // Ignore tracking errors
+  }
+}
+
+function untrackCollection (collectionPath) {
+  try {
+    const existing = SqliteStore.findOne(FIRESTORE_METADATA, { collectionName: collectionPath })
+    if (existing) {
+      SqliteStore.delete(FIRESTORE_METADATA, existing._id)
+    }
+  } catch (error) {
+    // Ignore tracking errors
+  }
+}

package/src/api/firestore/Router.js

@@ -0,0 +1,23 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1 = new KoaRouter({ prefix: '/v1/firestore' })
+
+v1.post('/projects/list', Controllers.listProjects)
+v1.post('/collections/list', Controllers.listCollections)
+v1.post('/documents/list', Controllers.listDocuments)
+v1.post('/documents/get', Controllers.getDocument)
+v1.post('/documents/create', Controllers.createDocument)
+v1.post('/documents/update', Controllers.updateDocument)
+v1.post('/documents/delete', Controllers.deleteDocument)
+v1.post('/documents/delete-by-query', Controllers.deleteByQuery)
+v1.post('/documents/delete-by-prefix', Controllers.deleteByPrefix)
+v1.post('/documents/delete-batch', Controllers.deleteBatch)
+v1.post('/query/execute', Controllers.executeQuery)
+v1.post('/collection/clear', Controllers.clearCollection)
+v1.get('/changes/stream', Controllers.streamChanges)
+
+Router.use(v1.routes())
+
+export { Router }