@edgedev/firebase 2.1.79 → 2.2.80

package/src/functions.js

@@ -1,3 +1,4 @@
 // START @edge/firebase functions
 exports.edgeFirebase = require('./edgeFirebase')
+exports.cms = require('./cms')
 // END @edge/firebase functions

package/src/index.js

@@ -2,4 +2,5 @@ require('dotenv').config({ path: process.env.NODE_ENV === 'production' ? '.env.p
 
 // START @edge/firebase functions
 exports.edgeFirebase = require('./edgeFirebase')
-// END @edge/firebase functions
+exports.cms = require('./cms')
+// END @edge/firebase functions

package/src/kv/kvClient.js

@@ -0,0 +1,146 @@
+// kvClient.js
+const axios = require('axios')
+const FormData = require('form-data')
+
+const accountId = process.env.CF_ACCOUNT_ID
+const namespaceId = process.env.CLOUDFLARE_NAMESPACE_ID
+const apiKey = process.env.CLOUDFLARE_API_KEY
+
+if (!accountId || !namespaceId || !apiKey) {
+  console.warn('[kvClient] Missing CF env vars: CF_ACCOUNT_ID, CLOUDFLARE_NAMESPACE_ID, CLOUDFLARE_API_KEY')
+}
+
+const base = `https://api.cloudflare.com/client/v4/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`
+
+function parseJsonIfNeeded(body) {
+  if (body === null || body === undefined) {
+    return null
+  }
+  if (typeof body === 'object') {
+    return body
+  }
+  if (typeof body === 'string' && body.trim().length > 0) {
+    try {
+      return JSON.parse(body)
+    }
+    catch (e) {
+      console.warn('[kvClient] Failed to parse JSON body:', body.slice(0, 200))
+      return null
+    }
+  }
+  return null
+}
+
+function withWriteParams(url, opts) {
+  if (!opts) {
+    return url
+  }
+  const u = new URL(url)
+  if (opts.expiration_ttl != null) {
+    u.searchParams.set('expiration_ttl', String(opts.expiration_ttl))
+  }
+  if (opts.expiration != null) {
+    u.searchParams.set('expiration', String(opts.expiration))
+  }
+  return u.toString()
+}
+
+/**
+ * put(key, value, opts?)
+ * opts: { metadata?: object, expiration?: number, expiration_ttl?: number }
+ */
+async function put(key, value, opts = undefined) {
+  const url0 = `${base}/values/${encodeURIComponent(key)}`
+  const url = withWriteParams(url0, opts)
+  const headers = { Authorization: `Bearer ${apiKey}` }
+
+  if (opts && opts.metadata) {
+    const form = new FormData()
+    const val = value instanceof Buffer ? value : (typeof value === 'string' ? value : JSON.stringify(value))
+    form.append('value', val)
+    form.append('metadata', JSON.stringify(opts.metadata))
+    const formHeaders = form.getHeaders()
+    Object.assign(headers, formHeaders)
+    const res = await axios.put(url, form, { headers })
+    if (res.status !== 200) {
+      throw new Error(`KV put failed: ${res.status} ${res.statusText}`)
+    }
+    return
+  }
+
+  let data = value
+  if (typeof value === 'object' && !(value instanceof Buffer)) {
+    data = JSON.stringify(value)
+    headers['Content-Type'] = 'application/json'
+  }
+  else {
+    headers['Content-Type'] = 'text/plain'
+  }
+
+  const res = await axios.put(url, data, { headers })
+  if (res.status !== 200) {
+    throw new Error(`KV put failed: ${res.status} ${res.statusText}`)
+  }
+}
+
+async function putJson(key, obj, opts = undefined) {
+  return put(key, JSON.stringify(obj), opts)
+}
+
+/**
+ * Convenience for writing only metadata on an index key.
+ * Stores a tiny value ('1') and attaches the real JSON to metadata.
+ */
+async function putIndexMeta(key, metadata, opts = undefined) {
+  const meta = metadata && typeof metadata === 'object' ? metadata : {}
+  return put(key, '1', { ...(opts || {}), metadata: meta })
+}
+
+async function get(key, type = 'text') {
+  const url = `${base}/values/${encodeURIComponent(key)}`
+  try {
+    const res = await axios.get(url, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      responseType: 'text',
+      transformResponse: [x => x],
+    })
+    if (type === 'json') {
+      return parseJsonIfNeeded(res.data)
+    }
+    return res.data
+  }
+  catch (err) {
+    if (err?.response?.status === 404) {
+      return null
+    }
+    throw new Error(`KV get failed for ${key}: ${err.message}`)
+  }
+}
+
+async function del(key) {
+  const url = `${base}/values/${encodeURIComponent(key)}`
+  await Promise.allSettled([
+    axios.delete(url, { headers: { Authorization: `Bearer ${apiKey}` } }),
+  ])
+}
+
+/**
+ * List keys with optional prefix/limit/cursor.
+ * Returns { result, success, errors, messages } where result[i] has { name, expiration, metadata }.
+ */
+async function listKeys({ prefix = '', limit = 1000, cursor = '' } = {}) {
+  const u = new URL(`${base}/keys`)
+  if (prefix) {
+    u.searchParams.set('prefix', prefix)
+  }
+  if (limit != null) {
+    u.searchParams.set('limit', String(limit))
+  }
+  if (cursor) {
+    u.searchParams.set('cursor', cursor)
+  }
+  const res = await axios.get(u.toString(), { headers: { Authorization: `Bearer ${apiKey}` } })
+  return res.data
+}
+
+module.exports = { put, putJson, putIndexMeta, get, del, listKeys }

package/src/kv/kvMirror.js

@@ -0,0 +1,212 @@
+// kvMirror.js
+// Generic Firestore→Cloudflare KV mirroring helper.
+// - Writes a canonical KV key per Firestore doc (value = serialized data).
+// - Optionally writes index keys that carry JSON in **metadata** (value = '1').
+// - Index-key metadata always includes { canonical: <canonicalKey> }.
+// - Keeps a small manifest per canonical key to clean up all index keys on delete.
+
+const { onDocumentWritten } = require('../config.js')
+const kv = require('./kvClient')
+
+function json(x) {
+  return JSON.stringify(x)
+}
+
+function slugIndexValue(value, maxLength = 80) {
+  return String(value ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, maxLength)
+}
+
+function setDiff(oldArr = [], newArr = []) {
+  const A = new Set(oldArr)
+  const B = new Set(newArr)
+  const toRemove = [...A].filter(x => !B.has(x))
+  const toAdd = [...B].filter(x => !A.has(x))
+  return { toRemove, toAdd }
+}
+
+/**
+ * createKvMirrorHandler({
+ *   document: 'organizations/{orgId}/sites/{siteId}/published_posts/{postId}',
+ *   makeCanonicalKey: (params, data) => `post:${params.orgId}:${params.siteId}:${params.postId}`,
+ *   makeIndexKeys: (params, data) => [...],                  // optional
+ *   makeMetadata: (data, params) => ({ title: data.title }), // optional, merged with { canonical }
+ *   serialize: (data) => JSON.stringify(data),               // optional
+ *   timeoutSeconds: 180                                      // optional
+ * })
+ */
+function createKvMirrorHandler({
+  document,
+  makeCanonicalKey,
+  makeIndexKeys,
+  makeMetadata,
+  serialize = json,
+  timeoutSeconds = 180,
+}) {
+  return onDocumentWritten({ document, timeoutSeconds }, async (event) => {
+    const after = event.data?.after
+    const params = event.params || {}
+    const data = after?.exists ? after.data() : null
+
+    const canonicalKey = makeCanonicalKey(params, data)
+    const indexingEnabled = typeof makeIndexKeys === 'function'
+    const manifestKey = indexingEnabled ? `idx:manifest:${canonicalKey}` : null
+
+    if (!after?.exists) {
+      if (indexingEnabled) {
+        let prev = null
+        try {
+          prev = await kv.get(manifestKey, 'json')
+        }
+        catch (_) {
+          prev = null
+        }
+        const keys = Array.isArray(prev?.indexKeys) ? prev.indexKeys : []
+        const deletions = [
+          ...keys.map(k => kv.del(k)),
+          kv.del(canonicalKey),
+          kv.del(manifestKey),
+        ]
+        await Promise.allSettled(deletions)
+      }
+      else {
+        await kv.del(canonicalKey)
+      }
+      return
+    }
+
+    const baseMeta = { canonical: canonicalKey }
+    const customMetaCandidate = typeof makeMetadata === 'function' ? (makeMetadata(data, params) || null) : null
+    const metaValue = (customMetaCandidate && typeof customMetaCandidate === 'object')
+      ? { ...customMetaCandidate, canonical: canonicalKey }
+      : baseMeta
+
+    await kv.put(canonicalKey, serialize(data), { metadata: metaValue })
+
+    if (!indexingEnabled) {
+      return
+    }
+
+    const nextIndexKeys = (await Promise.resolve(makeIndexKeys(params, data)) || [])
+      .filter(Boolean)
+      .map(String)
+
+    let prev = null
+    try {
+      prev = await kv.get(manifestKey, 'json')
+    }
+    catch (_) {
+      prev = null
+    }
+
+    const oldIndexKeys = Array.isArray(prev?.indexKeys) ? prev.indexKeys : []
+    const { toRemove } = setDiff(oldIndexKeys, nextIndexKeys)
+
+    const upserts = nextIndexKeys.map(k => kv.putIndexMeta(k, metaValue))
+    await Promise.allSettled(upserts)
+
+    const removals = toRemove.map(k => kv.del(k))
+    await Promise.allSettled(removals)
+
+    await kv.put(manifestKey, { indexKeys: nextIndexKeys })
+  })
+}
+
+function createKvMirrorHandlerFromFields({
+  documentPath,
+  uniqueKey,
+  indexKeys = [],
+  metadataKeys = [],
+  serialize = json,
+}) {
+  if (!uniqueKey || typeof uniqueKey !== 'string') {
+    throw new Error('createKvMirrorHandlerFromFields requires uniqueKey (e.g. "{orgId}:{siteId}")')
+  }
+  const docIdParam = 'docId'
+  const basePath = documentPath || ''
+  const document = basePath.includes(`{${docIdParam}}`) ? basePath : `${basePath}/{${docIdParam}}`
+  const collection = String(basePath || '')
+    .replace(new RegExp(`/{${docIdParam}}$`), '')
+    .split('/')
+    .filter(Boolean)
+    .pop()
+
+  const resolveUniqueKey = (params) => {
+    const template = String(uniqueKey || '').trim()
+    if (!template)
+      return ''
+    const tokens = template.match(/\{[^}]+\}/g) || []
+    let missing = false
+    const value = template.replace(/\{([^}]+)\}/g, (_, key) => {
+      const resolved = params?.[key]
+      if (resolved === undefined || resolved === null || resolved === '') {
+        missing = true
+        return ''
+      }
+      return String(resolved)
+    })
+    if (missing)
+      return ''
+    if (tokens.length === 0)
+      return value
+    return value
+  }
+
+  const makeCanonicalKey = (params) => {
+    const resolvedKey = resolveUniqueKey(params)
+    const docId = params?.[docIdParam]
+    if (!collection || !docId || !resolvedKey)
+      return ''
+    return `${collection}:${resolvedKey}:${docId}`
+  }
+
+  const makeIndexKeys = (params, data) => {
+    const docId = params?.[docIdParam]
+    const resolvedKey = resolveUniqueKey(params)
+
+    if (!collection || !docId || !resolvedKey)
+      return []
+
+    const keys = []
+    const fields = Array.isArray(indexKeys) ? indexKeys : []
+    for (const field of fields) {
+      if (!field || typeof field !== 'string')
+        continue
+      const rawValue = data?.[field]
+      const values = Array.isArray(rawValue) ? rawValue : [rawValue]
+      for (const value of values) {
+        if (value === undefined || value === null || value === '')
+          continue
+        const slug = slugIndexValue(value)
+        if (!slug)
+          continue
+        keys.push(`idx:${collection}:${field}:${resolvedKey}:${slug}:${docId}`)
+      }
+    }
+    return keys
+  }
+
+  const makeMetadata = (data) => {
+    const meta = {}
+    const keys = Array.isArray(metadataKeys) ? metadataKeys : []
+    for (const key of keys) {
+      meta[key] = data?.[key] ?? ''
+    }
+    return meta
+  }
+
+  return createKvMirrorHandler({
+    document,
+    makeCanonicalKey,
+    makeIndexKeys: indexKeys.length ? makeIndexKeys : undefined,
+    makeMetadata: metadataKeys.length ? makeMetadata : undefined,
+    serialize,
+    timeoutSeconds: 180,
+  })
+}
+
+module.exports = { createKvMirrorHandler, createKvMirrorHandlerFromFields }

package/src/package.json

@@ -1,35 +1,41 @@
 {
-    "name": "functions",
-    "type": "commonjs",
-    "private": true,
-    "description": "Cloud Functions for Firebase",
-    "main": "index.js",
-    "engines": {
-        "node": "22"
-    },
-    "scripts": {
-        "serve": "firebase emulators:start --only functions",
-        "shell": "firebase functions:shell",
-        "start": "npm run shell",
-        "deploy": "firebase deploy --only functions",
-        "logs": "firebase functions:log"
-    },
-    "dependencies": {
-        "@google-cloud/pubsub": "^4.9.0",
-        "aws-sdk": "^2.1692.0",
-        "crypto": "^1.0.1",
-        "dotenv": "^16.3.1",
-        "exceljs": "^4.4.0",
-        "firebase-admin": "^13.0.2",
-        "firebase-functions": "^6.2.0",
-        "form-data": "^4.0.0",
-        "formidable-serverless": "^1.1.1",
-        "moment-timezone": "^0.5.43",
-        "openai": "^4.11.1",
-        "stripe": "^13.8.0",
-        "twilio": "^4.18.0"
-    },
-    "devDependencies": {
-        "firebase-functions-test": "^3.4.0"
-    }
-}
+  "name": "functions",
+  "type": "commonjs",
+  "private": true,
+  "description": "Cloud Functions for Firebase",
+  "main": "index.js",
+  "engines": {
+    "node": "22"
+  },
+  "scripts": {
+    "deploy": "firebase deploy --only functions",
+    "logs": "firebase functions:log",
+    "serve": "firebase emulators:start --only functions",
+    "shell": "firebase functions:shell",
+    "start": "npm run shell"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.582.0",
+    "@aws-sdk/s3-request-presigner": "^3.582.0",
+    "@google-cloud/pubsub": "^4.11.0",
+    "@google-cloud/functions-framework": "^3.4.5",
+    "@napi-rs/canvas": "^0.1.0",
+    "aws-sdk": "^2.1693.0",
+    "axios": "^1.7.2",
+    "cloudconvert": "^2.3.7",
+    "crypto": "^1.0.1",
+    "dotenv": "^16.6.1",
+    "exceljs": "^4.4.0",
+    "firebase-admin": "^13.6.0",
+    "firebase-functions": "^6.6.0",
+    "form-data": "^4.0.5",
+    "formidable-serverless": "^1.1.1",
+    "moment-timezone": "^0.5.48",
+    "openai": "^4.104.0",
+    "stripe": "^13.11.0",
+    "twilio": "^4.23.0"
+  },
+  "devDependencies": {
+    "firebase-functions-test": "^0.2.0"
+  }
+}

package/src/postinstall.sh

@@ -5,6 +5,63 @@ actual_dir=$(readlink -f $(dirname $0))
 # Get the project root directory by removing the node_modules directory path
 project_root=$(echo "$actual_dir" | awk '{gsub(/node_modules.*$/, ""); print}')
 
+merge_env_file () {
+  local src="$1"
+  local dest="$2"
+
+  if [ ! -f "$src" ]; then
+    return
+  fi
+
+  if [ ! -f "$dest" ]; then
+    cp "$src" "$dest"
+    return
+  fi
+
+  [ "$(tail -c1 "$dest")" != "" ] && echo "" >> "$dest"
+
+  while IFS= read -r line; do
+    if [ -z "$line" ]; then
+      continue
+    fi
+    if echo "$line" | grep -qE '^[A-Za-z0-9_]+='; then
+      key="${line%%=*}"
+      if ! grep -qE "^${key}=" "$dest"; then
+        echo "$line" >> "$dest"
+      fi
+    fi
+  done < "$src"
+}
+
+merge_package_json () {
+  local src="$1"
+  local dest="$2"
+
+  if [ ! -f "$src" ] || [ ! -f "$dest" ]; then
+    return
+  fi
+
+  node - "$src" "$dest" <<'NODE'
+const fs = require('fs')
+const [,, srcPath, destPath] = process.argv
+const src = JSON.parse(fs.readFileSync(srcPath, 'utf8'))
+const dest = JSON.parse(fs.readFileSync(destPath, 'utf8'))
+const sections = ['dependencies', 'devDependencies']
+
+for (const section of sections) {
+  const srcDeps = src[section] || {}
+  if (!dest[section])
+    dest[section] = {}
+  for (const [name, version] of Object.entries(srcDeps)) {
+    if (!dest[section][name])
+      dest[section][name] = version
+  }
+}
+
+fs.writeFileSync(destPath, `${JSON.stringify(dest, null, 2)}\n`)
+NODE
+}
+
 
 # Check if the destination file exists
 if [ ! -f "$project_root/firestore.rules" ]; then
@@ -47,52 +104,32 @@ fi
 
 cp ./src/edgeFirebase.js "$project_root/functions/edgeFirebase.js"
 cp ./src/config.js "$project_root/functions/config.js"
+cp ./src/cms.js "$project_root/functions/cms.js"
 
-if [ ! -f "$project_root/functions/index.js" ]; then
-  cp ./src/index.js "$project_root/functions/index.js"
-fi
-
-if [ ! -f "$project_root/functions/.env.dev" ]; then
-  cp ./src/.env.dev "$project_root/functions/.env.dev"
+if [ ! -d "$project_root/functions/kv" ]; then
+  mkdir -p "$project_root/functions/kv"
 fi
 
-if [ ! -f "$project_root/functions/.env.prod" ]; then
-  cp ./src/.env.prod "$project_root/functions/.env.prod"
-fi
+cp ./src/kv/*.js "$project_root/functions/kv/"
 
-if [ ! -f "$project_root/.env.dev" ]; then
-  cp ./src/.env.development "$project_root/.env.dev"
+if [ ! -f "$project_root/functions/index.js" ]; then
+  cp ./src/index.js "$project_root/functions/index.js"
+else
+  sed -i.backup '/\/\/ START @edge\/firebase functions/,/\/\/ END @edge\/firebase functions/d' "$project_root/functions/index.js"
+  [ "$(tail -c1 $project_root/functions/index.js)" != "" ] && echo "" >> "$project_root/functions/index.js"
+  awk '/\/\/ START @edge\/firebase functions/,/\/\/ END @edge\/firebase functions/' ./src/functions.js | \
+    sed '1d;$d' | \
+    sed -e '1s/^/\/\/ START @edge\/firebase functions\n/' -e '$s/$/\n\/\/ END @edge\/firebase functions/' \
+    >> "$project_root/functions/index.js";
 fi
 
-if [ ! -f "$project_root/.env" ]; then
-  cp ./src/.env.production "$project_root/.env"
-fi
+merge_env_file "./src/.env.dev" "$project_root/functions/.env.dev"
+merge_env_file "./src/.env.prod" "$project_root/functions/.env.prod"
+merge_env_file "./src/.env.development" "$project_root/.env.dev"
+merge_env_file "./src/.env.production" "$project_root/.env"
 
 if [ ! -f "$project_root/functions/package.json" ]; then
   cp ./src/package.json "$project_root/functions/package.json"
-  cd "$project_root/functions"
-  npm install --no-audit --silent
-  cd "$project_root"
+else
+  merge_package_json "$actual_dir/package.json" "$project_root/functions/package.json"
 fi
-
-# Upgrade specific npm packages in the functions directory
-cd "$project_root/functions"
-
-# List of packages to upgrade
-npm install --save \
-    "@google-cloud/pubsub@^4.9.0" \
-    "aws-sdk@^2.1692.0" \
-    "crypto@^1.0.1" \
-    "dotenv@^16.3.1" \
-    "exceljs@^4.4.0" \
-    "firebase-admin@^13.0.2" \
-    "firebase-functions@^6.2.0" \
-    "form-data@^4.0.0" \
-    "formidable-serverless@^1.1.1" \
-    "moment-timezone@^0.5.43" \
-    "openai@^4.11.1" \
-    "stripe@^13.8.0" \
-    "twilio@^4.18.0"
-
-# Return to the project root
-cd "$project_root"