firebase-dataconnect-bootstrap 1.1.0 → 1.2.1

package/dist/main.js

@@ -50,10 +50,7 @@ function appendIfMissing(content, appendLine) {
 }
 function detectModuleStyle(entryPath, packageJson) {
     const ext = path.extname(entryPath);
-    if (ext === ".ts") {
-        return "esm";
-    }
-    if (ext === ".mjs") {
+    if (ext === ".ts" || ext === ".mjs") {
         return "esm";
     }
     if (ext === ".cjs") {
@@ -64,6 +61,22 @@ function detectModuleStyle(entryPath, packageJson) {
     }
     return "cjs";
 }
+function buildGeneratedImportPath(moduleStyle, extension, moduleBaseName) {
+    if (moduleStyle === "cjs") {
+        if (extension === ".cjs") {
+            return `./${moduleBaseName}.cjs`;
+        }
+        return `./${moduleBaseName}`;
+    }
+    if (extension === ".ts") {
+        return `./${moduleBaseName}.js`;
+    }
+    return `./${moduleBaseName}${extension}`;
+}
+function toSafeFileSegment(value) {
+    const normalized = value.replace(/[^A-Za-z0-9_-]/g, "_");
+    return normalized || "generated";
+}
 function buildDataconnectYaml(config) {
     return `specVersion: "v1alpha"
 serviceId: "${config.serviceId}"
@@ -124,13 +137,36 @@ function buildMutationsGql() {
 }
 `;
 }
-function buildFunctionModule({ style, functionName, documentPath, region }) {
+function buildEmbeddingModule(style) {
     if (style === "cjs") {
-        return `const { onDocumentWritten } = require("firebase-functions/v2/firestore");
+        return `/**
+ * Replace this function with your embedding provider implementation.
+ * Return a numeric vector (number[]) for the given text.
+ */
+async function embedText(_text) {
+  return null;
+}
+
+module.exports = { embedText };
+`;
+    }
+    return `/**
+ * Replace this function with your embedding provider implementation.
+ * Return a numeric vector (number[]) for the given text.
+ */
+export async function embedText(_text) {
+  return null;
+}
+`;
+}
+function buildFunctionModule({ style, config, embeddingImportPath }) {
+    if (style === "cjs") {
+        if (!config.vectorSearch.enabled) {
+            return `const { onDocumentWritten } = require("firebase-functions/v2/firestore");
 const logger = require("firebase-functions/logger");
 
-const ${functionName} = onDocumentWritten(
-  { document: "${documentPath}", region: "${region}" },
+const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
   async (event) => {
     logger.info("Firestore onDocumentWritten fired", {
       params: event.params,
@@ -142,14 +178,61 @@ const ${functionName} = onDocumentWritten(
   }
 );
 
-module.exports = { ${functionName} };
+module.exports = { ${config.functionName} };
+`;
+        }
+        return `const { onDocumentWritten } = require("firebase-functions/v2/firestore");
+const logger = require("firebase-functions/logger");
+const { embedText } = require("${embeddingImportPath}");
+
+const SOURCE_TEXT_FIELD = ${JSON.stringify(config.vectorSearch.sourceTextField)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+
+const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
+  async (event) => {
+    if (!event.data?.after?.exists) {
+      return;
+    }
+
+    const afterData = event.data.after.data();
+    const sourceText = String(afterData?.[SOURCE_TEXT_FIELD] ?? "").trim();
+    if (!sourceText) {
+      logger.info("Skip embedding update because source text field is empty.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    const vector = await embedText(sourceText);
+    const validVector =
+      Array.isArray(vector) && vector.length > 0 && vector.every((value) => Number.isFinite(value));
+    if (!validVector) {
+      logger.warn("Embedding provider returned an invalid vector.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    await event.data.after.ref.set({ [VECTOR_FIELD]: vector }, { merge: true });
+    logger.info("Updated vector field from source text.", {
+      field: VECTOR_FIELD,
+      document: event.data.after.ref.path
+    });
+  }
+);
+
+module.exports = { ${config.functionName} };
 `;
     }
-    return `import { onDocumentWritten } from "firebase-functions/v2/firestore";
+    if (!config.vectorSearch.enabled) {
+        return `import { onDocumentWritten } from "firebase-functions/v2/firestore";
 import * as logger from "firebase-functions/logger";
 
-export const ${functionName} = onDocumentWritten(
-  { document: "${documentPath}", region: "${region}" },
+export const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
   async (event) => {
     logger.info("Firestore onDocumentWritten fired", {
       params: event.params,
@@ -160,6 +243,266 @@ export const ${functionName} = onDocumentWritten(
     return;
   }
 );
+`;
+    }
+    return `import { onDocumentWritten } from "firebase-functions/v2/firestore";
+import * as logger from "firebase-functions/logger";
+import { embedText } from "${embeddingImportPath}";
+
+const SOURCE_TEXT_FIELD = ${JSON.stringify(config.vectorSearch.sourceTextField)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+
+export const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
+  async (event) => {
+    if (!event.data?.after?.exists) {
+      return;
+    }
+
+    const afterData = event.data.after.data();
+    const sourceText = String(afterData?.[SOURCE_TEXT_FIELD] ?? "").trim();
+    if (!sourceText) {
+      logger.info("Skip embedding update because source text field is empty.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    const vector = await embedText(sourceText);
+    const validVector =
+      Array.isArray(vector) && vector.length > 0 && vector.every((value) => Number.isFinite(value));
+    if (!validVector) {
+      logger.warn("Embedding provider returned an invalid vector.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    await event.data.after.ref.set({ [VECTOR_FIELD]: vector }, { merge: true });
+    logger.info("Updated vector field from source text.", {
+      field: VECTOR_FIELD,
+      document: event.data.after.ref.path
+    });
+  }
+);
+`;
+}
+function buildVectorSearchOnRequestModule(style, config, embeddingImportPath) {
+    const returnFields = JSON.stringify(config.vectorSearch.returnFields);
+    if (style === "cjs") {
+        return `const { onRequest } = require("firebase-functions/v2/https");
+const logger = require("firebase-functions/logger");
+const admin = require("firebase-admin");
+const { embedText } = require("${embeddingImportPath}");
+
+if (admin.apps.length === 0) {
+  admin.initializeApp();
+}
+
+const db = admin.firestore();
+const COLLECTION_PATH = ${JSON.stringify(config.vectorSearch.collectionPath)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+const RETURN_FIELDS = ${returnFields};
+const DEFAULT_TOP_K = ${config.vectorSearch.defaultTopK};
+
+function normalizeVector(raw) {
+  if (!Array.isArray(raw)) {
+    return null;
+  }
+  if (raw.length === 0) {
+    return null;
+  }
+  const vector = raw.map((value) => Number(value));
+  if (vector.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  return vector;
+}
+
+function cosineSimilarity(left, right) {
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    dot += left[i] * right[i];
+    leftNorm += left[i] * left[i];
+    rightNorm += right[i] * right[i];
+  }
+  const denom = Math.sqrt(leftNorm) * Math.sqrt(rightNorm);
+  if (denom === 0) {
+    return Number.NaN;
+  }
+  return dot / denom;
+}
+
+function pickFields(data) {
+  const picked = {};
+  for (const field of RETURN_FIELDS) {
+    if (field in data) {
+      picked[field] = data[field];
+    }
+  }
+  return picked;
+}
+
+const ${config.vectorSearch.functionName} = onRequest(
+  { region: ${JSON.stringify(config.region)}, cors: true },
+  async (req, res) => {
+    try {
+      const payload = req.method === "GET" ? req.query : req.body ?? {};
+      let queryVector = normalizeVector(payload.vector);
+      const queryText = typeof payload.query === "string" ? payload.query.trim() : "";
+      const rawTopK = Number.parseInt(String(payload.topK ?? DEFAULT_TOP_K), 10);
+      const topK = Number.isFinite(rawTopK) && rawTopK > 0 ? rawTopK : DEFAULT_TOP_K;
+
+      if (!queryVector && queryText) {
+        queryVector = normalizeVector(await embedText(queryText));
+      }
+      if (!queryVector) {
+        res.status(400).json({
+          error: "Provide 'vector' (number[]) or implement embedText and send 'query'."
+        });
+        return;
+      }
+
+      const snapshot = await db.collection(COLLECTION_PATH).get();
+      const scored = [];
+      snapshot.forEach((doc) => {
+        const data = doc.data();
+        const candidate = normalizeVector(data[VECTOR_FIELD]);
+        if (!candidate || candidate.length !== queryVector.length) {
+          return;
+        }
+        const score = cosineSimilarity(queryVector, candidate);
+        if (!Number.isFinite(score)) {
+          return;
+        }
+        scored.push({
+          id: doc.id,
+          score,
+          data: pickFields(data)
+        });
+      });
+
+      scored.sort((a, b) => b.score - a.score);
+      res.status(200).json({
+        total: scored.length,
+        results: scored.slice(0, topK)
+      });
+    } catch (error) {
+      logger.error("Vector search request failed", error);
+      res.status(500).json({ error: "Vector search failed." });
+    }
+  }
+);
+
+module.exports = { ${config.vectorSearch.functionName} };
+`;
+    }
+    return `import { onRequest } from "firebase-functions/v2/https";
+import * as logger from "firebase-functions/logger";
+import admin from "firebase-admin";
+import { embedText } from "${embeddingImportPath}";
+
+if (admin.apps.length === 0) {
+  admin.initializeApp();
+}
+
+const db = admin.firestore();
+const COLLECTION_PATH = ${JSON.stringify(config.vectorSearch.collectionPath)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+const RETURN_FIELDS = ${returnFields};
+const DEFAULT_TOP_K = ${config.vectorSearch.defaultTopK};
+
+function normalizeVector(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return null;
+  }
+  const vector = raw.map((value) => Number(value));
+  if (vector.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  return vector;
+}
+
+function cosineSimilarity(left, right) {
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    dot += left[i] * right[i];
+    leftNorm += left[i] * left[i];
+    rightNorm += right[i] * right[i];
+  }
+  const denom = Math.sqrt(leftNorm) * Math.sqrt(rightNorm);
+  if (denom === 0) {
+    return Number.NaN;
+  }
+  return dot / denom;
+}
+
+function pickFields(data) {
+  const picked = {};
+  for (const field of RETURN_FIELDS) {
+    if (field in data) {
+      picked[field] = data[field];
+    }
+  }
+  return picked;
+}
+
+export const ${config.vectorSearch.functionName} = onRequest(
+  { region: ${JSON.stringify(config.region)}, cors: true },
+  async (req, res) => {
+    try {
+      const payload = req.method === "GET" ? req.query : req.body ?? {};
+      let queryVector = normalizeVector(payload.vector);
+      const queryText = typeof payload.query === "string" ? payload.query.trim() : "";
+      const rawTopK = Number.parseInt(String(payload.topK ?? DEFAULT_TOP_K), 10);
+      const topK = Number.isFinite(rawTopK) && rawTopK > 0 ? rawTopK : DEFAULT_TOP_K;
+
+      if (!queryVector && queryText) {
+        queryVector = normalizeVector(await embedText(queryText));
+      }
+      if (!queryVector) {
+        res.status(400).json({
+          error: "Provide 'vector' (number[]) or implement embedText and send 'query'."
+        });
+        return;
+      }
+
+      const snapshot = await db.collection(COLLECTION_PATH).get();
+      const scored = [];
+      snapshot.forEach((doc) => {
+        const data = doc.data();
+        const candidate = normalizeVector(data[VECTOR_FIELD]);
+        if (!candidate || candidate.length !== queryVector.length) {
+          return;
+        }
+        const score = cosineSimilarity(queryVector, candidate);
+        if (!Number.isFinite(score)) {
+          return;
+        }
+        scored.push({
+          id: doc.id,
+          score,
+          data: pickFields(data)
+        });
+      });
+
+      scored.sort((a, b) => b.score - a.score);
+      res.status(200).json({
+        total: scored.length,
+        results: scored.slice(0, topK)
+      });
+    } catch (error) {
+      logger.error("Vector search request failed", error);
+      res.status(500).json({ error: "Vector search failed." });
+    }
+  }
+);
 `;
 }
 async function ensureFirebaseRc(targetDir, projectId) {
@@ -266,41 +609,107 @@ admin.initializeApp();
 `, "utf8");
     return { entryPath: defaultEntry, created: defaultEntry };
 }
-async function ensureFunctionExport(targetDir, config, entryRelativePath) {
+async function resolveEntryContext(targetDir, entryRelativePath) {
     const functionsPackage = await readJsonIfExists(path.join(targetDir, "functions", "package.json"));
     const entryFullPath = path.join(targetDir, entryRelativePath);
     const moduleStyle = detectModuleStyle(entryFullPath, functionsPackage);
     const extension = path.extname(entryRelativePath) || ".js";
-    const generatedFileName = `firestoreOnDocumentWritten${extension}`;
-    const generatedRelativePath = path.join(path.dirname(entryRelativePath), generatedFileName);
-    const generatedBaseName = path.basename(generatedFileName, extension);
-    const generatedImportPath = moduleStyle === "esm"
-        ? extension === ".ts"
-            ? `./${generatedBaseName}.js`
-            : `./${generatedFileName}`
-        : `./${generatedBaseName}`;
+    return {
+        moduleStyle,
+        extension,
+        entryRelativePath,
+        entryFullPath
+    };
+}
+async function ensureFunctionExport(targetDir, config, context) {
+    const onWriteModuleBaseName = `onDocumentWritten_${toSafeFileSegment(config.functionName)}`;
+    const generatedFileName = `${onWriteModuleBaseName}${context.extension}`;
+    const generatedRelativePath = path.join(path.dirname(context.entryRelativePath), generatedFileName);
+    const generatedImportPath = buildGeneratedImportPath(context.moduleStyle, context.extension, onWriteModuleBaseName);
+    const embeddingModuleBaseName = `vectorSearchEmbedding_${toSafeFileSegment(config.functionName)}`;
+    const embeddingImportPath = buildGeneratedImportPath(context.moduleStyle, context.extension, embeddingModuleBaseName);
     const generatedFullPath = path.join(targetDir, generatedRelativePath);
     const functionModuleText = buildFunctionModule({
-        style: moduleStyle,
-        functionName: config.functionName,
-        documentPath: config.documentPath,
-        region: config.region
+        style: context.moduleStyle,
+        config,
+        embeddingImportPath
     });
     await writeFile(generatedFullPath, functionModuleText, "utf8");
-    const entryText = (await readFile(entryFullPath, "utf8")).trimEnd();
-    const exportLine = moduleStyle === "cjs"
+    const entryText = (await readFile(context.entryFullPath, "utf8")).trimEnd();
+    const exportLine = context.moduleStyle === "cjs"
         ? `exports.${config.functionName} = require("${generatedImportPath}").${config.functionName};`
         : `export { ${config.functionName} } from "${generatedImportPath}";`;
     const updated = appendIfMissing(entryText, exportLine);
     if (updated.changed) {
-        await writeFile(entryFullPath, `${updated.content}`, "utf8");
+        await writeFile(context.entryFullPath, updated.content, "utf8");
     }
     return {
         generatedRelativePath: toPosixPath(generatedRelativePath),
-        entryRelativePath: toPosixPath(entryRelativePath),
+        entryRelativePath: toPosixPath(context.entryRelativePath),
         entryUpdated: updated.changed
     };
 }
+async function ensureVectorSearchScaffold(targetDir, config, context) {
+    if (!config.vectorSearch.enabled) {
+        return null;
+    }
+    const folder = path.dirname(context.entryRelativePath);
+    const onRequestModuleBaseName = `vectorSearchOnRequest_${toSafeFileSegment(config.vectorSearch.functionName)}`;
+    const embeddingModuleBaseName = `vectorSearchEmbedding_${toSafeFileSegment(config.functionName)}`;
+    const onRequestFileName = `${onRequestModuleBaseName}${context.extension}`;
+    const embeddingFileName = `${embeddingModuleBaseName}${context.extension}`;
+    const onRequestRelativePath = path.join(folder, onRequestFileName);
+    const embeddingRelativePath = path.join(folder, embeddingFileName);
+    const onRequestFullPath = path.join(targetDir, onRequestRelativePath);
+    const embeddingFullPath = path.join(targetDir, embeddingRelativePath);
+    const embeddingImportPath = buildGeneratedImportPath(context.moduleStyle, context.extension, embeddingModuleBaseName);
+    const onRequestImportPath = buildGeneratedImportPath(context.moduleStyle, context.extension, onRequestModuleBaseName);
+    await writeFile(onRequestFullPath, buildVectorSearchOnRequestModule(context.moduleStyle, config, embeddingImportPath), "utf8");
+    const embeddingCreated = await writeTextIfMissing(embeddingFullPath, buildEmbeddingModule(context.moduleStyle));
+    const entryText = (await readFile(context.entryFullPath, "utf8")).trimEnd();
+    const exportLine = context.moduleStyle === "cjs"
+        ? `exports.${config.vectorSearch.functionName} = require("${onRequestImportPath}").${config.vectorSearch.functionName};`
+        : `export { ${config.vectorSearch.functionName} } from "${onRequestImportPath}";`;
+    const updated = appendIfMissing(entryText, exportLine);
+    if (updated.changed) {
+        await writeFile(context.entryFullPath, updated.content, "utf8");
+    }
+    return {
+        generatedRelativePath: toPosixPath(onRequestRelativePath),
+        embeddingRelativePath: toPosixPath(embeddingRelativePath),
+        entryRelativePath: toPosixPath(context.entryRelativePath),
+        entryUpdated: updated.changed,
+        embeddingCreated
+    };
+}
+async function persistBootstrapConfig(targetDir, config) {
+    const filePath = path.join(targetDir, config.configFileName);
+    const currentTarget = {
+        documentPath: config.documentPath,
+        functionName: config.functionName,
+        vectorSearch: config.vectorSearch
+    };
+    const mergedTargets = [...config.existingTargets];
+    const existingIndex = mergedTargets.findIndex((target) => target.functionName === currentTarget.functionName);
+    if (existingIndex >= 0) {
+        mergedTargets[existingIndex] = currentTarget;
+    }
+    else {
+        mergedTargets.push(currentTarget);
+    }
+    const persisted = {
+        projectId: config.projectId,
+        region: config.region,
+        serviceId: config.serviceId,
+        location: config.location,
+        installDependencies: config.installDependencies,
+        configFileName: config.configFileName,
+        targets: mergedTargets,
+        lastTargetFunctionName: currentTarget.functionName
+    };
+    await writeJson(filePath, persisted);
+    return toPosixPath(config.configFileName);
+}
 async function runNpmInstall(functionsDir) {
     await new Promise((resolvePromise, rejectPromise) => {
         const child = spawn("npm", ["install"], {
@@ -350,11 +759,26 @@ export async function run(config) {
     else {
         summaryLines.push(`Using existing ${entryPath}`);
     }
-    const exportResult = await ensureFunctionExport(targetDir, config, entryPath);
-    summaryLines.push(`Updated ${exportResult.generatedRelativePath}`);
-    summaryLines.push(exportResult.entryUpdated
-        ? `Appended export in ${exportResult.entryRelativePath}`
-        : `Export already present in ${exportResult.entryRelativePath}`);
+    const context = await resolveEntryContext(targetDir, entryPath);
+    const documentWriteResult = await ensureFunctionExport(targetDir, config, context);
+    summaryLines.push(`Updated ${documentWriteResult.generatedRelativePath}`);
+    summaryLines.push(documentWriteResult.entryUpdated
+        ? `Appended export in ${documentWriteResult.entryRelativePath}`
+        : `Export already present in ${documentWriteResult.entryRelativePath}`);
+    const vectorSearchResult = await ensureVectorSearchScaffold(targetDir, config, context);
+    if (vectorSearchResult) {
+        summaryLines.push(`Updated ${vectorSearchResult.generatedRelativePath}`);
+        summaryLines.push(vectorSearchResult.embeddingCreated
+            ? `Created ${vectorSearchResult.embeddingRelativePath}`
+            : `Using existing ${vectorSearchResult.embeddingRelativePath}`);
+        summaryLines.push(vectorSearchResult.entryUpdated
+            ? `Appended export in ${vectorSearchResult.entryRelativePath}`
+            : `Vector search export already present in ${vectorSearchResult.entryRelativePath}`);
+    }
+    else {
+        summaryLines.push("Skipped vector search scaffolding");
+    }
+    summaryLines.push(`Updated ${await persistBootstrapConfig(targetDir, config)}`);
     if (config.installDependencies) {
         const functionsDir = path.join(targetDir, "functions");
         await runNpmInstall(functionsDir);

package/dist/prompt.d.ts

@@ -0,0 +1,2 @@
+import type { CliArgs, SetupConfig } from "./types.js";
+export declare function collectConfig(parsed: CliArgs): Promise<SetupConfig>;