firebase-dataconnect-bootstrap 1.1.0 → 1.2.1

package/dist/prompt.js

@@ -1,6 +1,11 @@
 import { resolve } from "node:path";
+import { readFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+const DEFAULT_CONFIG_FILE = ".firebase-dataconnect-bootstrap.json";
+const DEFAULT_RETURN_FIELDS = ["title", "summary", "createdAt"];
+const DEFAULT_DOCUMENT_PATH = "meetingSummaries/{summaryId}";
+const NEW_COLLECTION_DOCUMENT_PATH = "newCollection/{docId}";
 function normalizeFunctionName(name) {
     const cleaned = name.replace(/[^A-Za-z0-9_$]/g, "_");
     if (!cleaned) {
@@ -11,33 +16,208 @@ function normalizeFunctionName(name) {
     }
     return `fn_${cleaned}`;
 }
-function normalizeConfig(partial) {
-    const targetDir = resolve(partial.targetDir ?? process.cwd());
-    const region = partial.region?.trim() || "us-central1";
-    const projectId = partial.projectId?.trim() || "";
-    const serviceId = partial.serviceId?.trim() || `${projectId || "my-project"}-service`;
-    const location = partial.location?.trim() || region;
-    const documentPath = partial.documentPath?.trim() || "meetingSummaries/{summaryId}";
-    const functionName = normalizeFunctionName(partial.functionName?.trim() || "onMeetingSummaryWritten");
-    const installDependencies = typeof partial.installDependencies === "boolean" ? partial.installDependencies : true;
+function toCsv(fields) {
+    return fields.join(",");
+}
+function parseCsvFields(value) {
+    const fields = value
+        .split(",")
+        .map((field) => field.trim())
+        .filter(Boolean);
+    return fields.length > 0 ? fields : [...DEFAULT_RETURN_FIELDS];
+}
+function deriveCollectionPath(documentPath) {
+    const segments = documentPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+        return "meetingSummaries";
+    }
+    while (segments.length > 0 && segments[segments.length - 1].startsWith("{")) {
+        segments.pop();
+    }
+    if (segments.length === 0) {
+        return "meetingSummaries";
+    }
+    return segments.join("/");
+}
+function toPascalCase(input) {
+    const tokens = input
+        .split(/[^A-Za-z0-9]+/)
+        .map((token) => token.trim())
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return "Collection";
+    }
+    return tokens.map((token) => `${token[0].toUpperCase()}${token.slice(1)}`).join("");
+}
+function deriveWriteFunctionName(documentPath) {
+    const collection = deriveCollectionPath(documentPath);
+    return normalizeFunctionName(`on${toPascalCase(collection)}Written`);
+}
+function deriveSearchFunctionName(documentPath) {
+    const collection = deriveCollectionPath(documentPath);
+    return normalizeFunctionName(`search${toPascalCase(collection)}ByVector`);
+}
+function normalizeVectorSearch(partialVectorSearch, documentPath) {
+    const source = partialVectorSearch ?? {};
+    const collectionPath = source.collectionPath?.trim() || deriveCollectionPath(documentPath);
+    const sourceTextField = source.sourceTextField?.trim() || "summary";
+    const vectorField = source.vectorField?.trim() || "embedding";
+    const returnFields = source.returnFields?.length ? source.returnFields : [...DEFAULT_RETURN_FIELDS];
+    const functionName = normalizeFunctionName(source.functionName?.trim() || deriveSearchFunctionName(documentPath));
+    const rawTopK = typeof source.defaultTopK === "number" && Number.isFinite(source.defaultTopK)
+        ? Math.floor(source.defaultTopK)
+        : 5;
+    const defaultTopK = rawTopK > 0 ? rawTopK : 5;
+    const enabled = typeof source.enabled === "boolean" ? source.enabled : false;
+    return {
+        enabled,
+        collectionPath,
+        sourceTextField,
+        vectorField,
+        returnFields,
+        functionName,
+        defaultTopK
+    };
+}
+function normalizeTarget(partialTarget) {
+    const documentPath = partialTarget.documentPath?.trim() || DEFAULT_DOCUMENT_PATH;
+    const functionName = normalizeFunctionName(partialTarget.functionName?.trim() || deriveWriteFunctionName(documentPath));
+    const vectorSearch = normalizeVectorSearch(partialTarget.vectorSearch, documentPath);
     return {
-        targetDir,
-        projectId,
-        region,
-        serviceId,
-        location,
         documentPath,
         functionName,
-        installDependencies
+        vectorSearch
     };
 }
+function normalizeSavedConfig(raw, configFileName) {
+    const source = typeof raw === "object" && raw !== null ? raw : {};
+    const rawTargets = Array.isArray(source.targets)
+        ? source.targets
+        : source.documentPath
+            ? [
+                {
+                    documentPath: source.documentPath,
+                    functionName: source.functionName,
+                    vectorSearch: source.vectorSearch
+                }
+            ]
+            : [];
+    const targets = rawTargets
+        .filter((entry) => typeof entry === "object" && entry !== null)
+        .map((entry) => normalizeTarget(entry));
+    return {
+        projectId: typeof source.projectId === "string" ? source.projectId : "",
+        region: typeof source.region === "string" ? source.region : "us-central1",
+        serviceId: typeof source.serviceId === "string" ? source.serviceId : "",
+        location: typeof source.location === "string" ? source.location : "",
+        installDependencies: typeof source.installDependencies === "boolean" ? source.installDependencies : true,
+        configFileName: typeof source.configFileName === "string" && source.configFileName
+            ? source.configFileName
+            : configFileName,
+        targets,
+        lastTargetFunctionName: typeof source.lastTargetFunctionName === "string" ? source.lastTargetFunctionName : undefined
+    };
+}
+async function loadSavedConfig(targetDir, configFileName) {
+    try {
+        const filePath = resolve(targetDir, configFileName);
+        const rawText = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(rawText);
+        return normalizeSavedConfig(parsed, configFileName);
+    }
+    catch {
+        return normalizeSavedConfig({}, configFileName);
+    }
+}
+function pickDefaultTarget(saved) {
+    if (saved.targets.length === 0) {
+        return normalizeTarget({});
+    }
+    if (saved.lastTargetFunctionName) {
+        const last = saved.targets.find((target) => target.functionName === saved.lastTargetFunctionName);
+        if (last) {
+            return last;
+        }
+    }
+    return saved.targets[0];
+}
+function hasTargetOverrides(parsed) {
+    if (parsed.documentPath || parsed.functionName) {
+        return true;
+    }
+    if (!parsed.vectorSearch) {
+        return false;
+    }
+    const vector = parsed.vectorSearch;
+    return Boolean(vector.enabled !== undefined ||
+        vector.collectionPath ||
+        vector.sourceTextField ||
+        vector.vectorField ||
+        vector.returnFields?.length ||
+        vector.functionName ||
+        vector.defaultTopK !== undefined);
+}
+function mergeTarget(base, parsed) {
+    return normalizeTarget({
+        ...base,
+        documentPath: parsed.documentPath ?? base.documentPath,
+        functionName: parsed.functionName ?? base.functionName,
+        vectorSearch: {
+            ...base.vectorSearch,
+            ...(parsed.vectorSearch ?? {})
+        }
+    });
+}
+function buildAddTargetDefaults(parsed) {
+    const documentPath = parsed.documentPath ?? NEW_COLLECTION_DOCUMENT_PATH;
+    return normalizeTarget({
+        documentPath,
+        functionName: parsed.functionName ?? deriveWriteFunctionName(documentPath),
+        vectorSearch: {
+            enabled: parsed.vectorSearch?.enabled ?? false,
+            collectionPath: parsed.vectorSearch?.collectionPath ?? deriveCollectionPath(documentPath),
+            sourceTextField: parsed.vectorSearch?.sourceTextField ?? "summary",
+            vectorField: parsed.vectorSearch?.vectorField ?? "embedding",
+            returnFields: parsed.vectorSearch?.returnFields ?? [...DEFAULT_RETURN_FIELDS],
+            functionName: parsed.vectorSearch?.functionName ?? deriveSearchFunctionName(documentPath),
+            defaultTopK: parsed.vectorSearch?.defaultTopK ?? 5
+        }
+    });
+}
 export async function collectConfig(parsed) {
-    const defaults = normalizeConfig(parsed);
+    const targetDir = resolve(parsed.targetDir ?? process.cwd());
+    const configFileName = parsed.configFileName?.trim() || DEFAULT_CONFIG_FILE;
+    const saved = await loadSavedConfig(targetDir, configFileName);
+    const projectId = parsed.projectId?.trim() || saved.projectId || "";
+    const region = parsed.region?.trim() || saved.region || "us-central1";
+    const serviceId = parsed.serviceId?.trim() || saved.serviceId || `${projectId || "my-project"}-service`;
+    const location = parsed.location?.trim() || saved.location || region;
+    const installDependencies = typeof parsed.installDependencies === "boolean" ? parsed.installDependencies : saved.installDependencies;
+    const defaultTarget = pickDefaultTarget(saved);
+    const addCollectionDefault = parsed.addCollection ?? false;
     if (parsed.yes) {
-        if (!defaults.projectId) {
+        if (!projectId) {
             throw new Error("`--yes` を使う場合は `--project` が必須です。");
         }
-        return defaults;
+        if (parsed.addCollection && !hasTargetOverrides(parsed)) {
+            throw new Error("`--add-collection --yes` を使う場合は --document など追加ターゲットの情報を指定してください。");
+        }
+        const resolvedTarget = parsed.addCollection
+            ? mergeTarget(buildAddTargetDefaults(parsed), parsed)
+            : mergeTarget(defaultTarget, parsed);
+        return {
+            targetDir,
+            projectId,
+            region,
+            serviceId,
+            location,
+            documentPath: resolvedTarget.documentPath,
+            functionName: resolvedTarget.functionName,
+            installDependencies,
+            configFileName,
+            vectorSearch: resolvedTarget.vectorSearch,
+            existingTargets: saved.targets
+        };
     }
     const rl = createInterface({ input, output });
     try {
@@ -49,27 +229,89 @@ export async function collectConfig(parsed) {
             }
             return value;
         };
+        const askBoolean = async (label, fallback) => {
+            const base = fallback ? "y" : "n";
+            const value = (await ask(label, base, true)).toLowerCase();
+            if (["y", "yes", "true", "1", "はい"].includes(value)) {
+                return true;
+            }
+            if (["n", "no", "false", "0", "いいえ"].includes(value)) {
+                return false;
+            }
+            throw new Error(`${label} は y か n を入力してください。`);
+        };
         console.log("Firebase Data Connect / Cloud Functions セットアップ");
         console.log("");
-        const targetDir = resolve(await ask("対象リポジトリのパス", defaults.targetDir, true));
-        const projectId = await ask("Firebase プロジェクトID", defaults.projectId || "my-project", true);
-        const region = await ask("Functions のリージョン", defaults.region, true);
-        const serviceId = await ask("Data Connect サービスID", `${projectId}-service`, true);
-        const location = await ask("Data Connect ロケーション", defaults.location || region, true);
-        const documentPath = await ask("Firestore ドキュメントパス", defaults.documentPath, true);
-        const rawFunctionName = await ask("関数のエクスポート名", defaults.functionName, true);
-        const functionName = normalizeFunctionName(rawFunctionName);
-        const installRaw = await ask("functions ディレクトリで npm install を実行しますか？ (y/n)", defaults.installDependencies ? "y" : "n", true);
-        const installDependencies = installRaw.toLowerCase().startsWith("y");
+        const selectedTargetDir = resolve(await ask("対象リポジトリのパス", targetDir, true));
+        const selectedProjectId = await ask("Firebase プロジェクトID", projectId || "my-project", true);
+        const selectedRegion = await ask("Functions のリージョン", region, true);
+        const selectedServiceId = await ask("Data Connect サービスID", serviceId || `${selectedProjectId}-service`, true);
+        const selectedLocation = await ask("Data Connect ロケーション", location || selectedRegion, true);
+        const selectedInstallDependencies = await askBoolean("functions ディレクトリで npm install を実行しますか？ (y/n)", installDependencies);
+        let addCollection = addCollectionDefault;
+        if (saved.targets.length > 0 && parsed.addCollection !== true) {
+            addCollection = await askBoolean("既存設定に新しいコレクション設定を追加しますか？ (y/n)", true);
+        }
+        let targetDefaults = defaultTarget;
+        if (addCollection) {
+            targetDefaults = buildAddTargetDefaults(parsed);
+        }
+        else if (saved.targets.length > 1) {
+            console.log("");
+            console.log("既存ターゲット:");
+            saved.targets.forEach((target, index) => {
+                console.log(`  ${index + 1}. ${target.functionName} (${target.documentPath})`);
+            });
+            const defaultIndex = Math.max(0, saved.targets.findIndex((target) => target.functionName === saved.lastTargetFunctionName));
+            const selectedIndexRaw = await ask("編集するターゲット番号", String(defaultIndex + 1), true);
+            const selectedIndex = Number.parseInt(selectedIndexRaw, 10);
+            if (!Number.isInteger(selectedIndex) || selectedIndex < 1 || selectedIndex > saved.targets.length) {
+                throw new Error("ターゲット番号が不正です。");
+            }
+            targetDefaults = saved.targets[selectedIndex - 1];
+        }
+        const baseTarget = mergeTarget(targetDefaults, parsed);
+        const documentPath = await ask("Firestore ドキュメントパス", baseTarget.documentPath, true);
+        const functionName = normalizeFunctionName(await ask("onDocumentWritten 関数のエクスポート名", baseTarget.functionName, true));
+        const vectorEnabled = await askBoolean("ベクトル検索と onRequest 検索関数を有効化しますか？ (y/n)", baseTarget.vectorSearch.enabled);
+        let vectorCollectionPath = baseTarget.vectorSearch.collectionPath;
+        let sourceTextField = baseTarget.vectorSearch.sourceTextField;
+        let vectorField = baseTarget.vectorSearch.vectorField;
+        let returnFields = baseTarget.vectorSearch.returnFields;
+        let searchFunctionName = baseTarget.vectorSearch.functionName;
+        let defaultTopK = baseTarget.vectorSearch.defaultTopK;
+        if (vectorEnabled) {
+            vectorCollectionPath = await ask("ベクトル検索対象のコレクションパス", baseTarget.vectorSearch.collectionPath, true);
+            sourceTextField = await ask("埋め込み作成対象のテキストフィールド", baseTarget.vectorSearch.sourceTextField, true);
+            vectorField = await ask("ベクトル保存先フィールド名", baseTarget.vectorSearch.vectorField, true);
+            returnFields = parseCsvFields(await ask("検索結果に返すフィールド（カンマ区切り）", toCsv(baseTarget.vectorSearch.returnFields), true));
+            searchFunctionName = normalizeFunctionName(await ask("onRequest 検索関数名", baseTarget.vectorSearch.functionName, true));
+            const defaultTopKText = await ask("ベクトル検索のデフォルト topK", String(baseTarget.vectorSearch.defaultTopK), true);
+            defaultTopK = Number.parseInt(defaultTopKText, 10);
+            if (Number.isNaN(defaultTopK) || defaultTopK <= 0) {
+                throw new Error("topK は 1 以上の整数で入力してください。");
+            }
+        }
         return {
-            targetDir,
-            projectId,
-            region,
-            serviceId,
-            location,
+            targetDir: selectedTargetDir,
+            projectId: selectedProjectId,
+            region: selectedRegion,
+            serviceId: selectedServiceId,
+            location: selectedLocation,
             documentPath,
             functionName,
-            installDependencies
+            installDependencies: selectedInstallDependencies,
+            configFileName,
+            vectorSearch: {
+                enabled: vectorEnabled,
+                collectionPath: vectorCollectionPath,
+                sourceTextField,
+                vectorField,
+                returnFields,
+                functionName: searchFunctionName,
+                defaultTopK
+            },
+            existingTargets: selectedTargetDir === targetDir ? saved.targets : []
         };
     }
     finally {

package/dist/search-client.d.ts

@@ -0,0 +1,40 @@
+export interface VectorSearchHit {
+    id: string;
+    score: number;
+    data: Record<string, unknown>;
+}
+export interface VectorSearchResponse {
+    total: number;
+    results: VectorSearchHit[];
+}
+export interface SearchByVectorInput {
+    endpoint: string;
+    vector?: number[];
+    query?: string;
+    topK?: number;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+interface MinimalResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+type MinimalFetch = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    signal?: AbortSignal;
+}) => Promise<MinimalResponse>;
+export declare function searchByVector(input: SearchByVectorInput, fetchImpl?: MinimalFetch): Promise<VectorSearchResponse>;
+export interface VectorSearchClientOptions {
+    endpoint: string;
+    headers?: Record<string, string>;
+    fetchImpl?: MinimalFetch;
+}
+export declare function createVectorSearchClient(options: VectorSearchClientOptions): {
+    search: (input: Omit<SearchByVectorInput, "endpoint">) => Promise<VectorSearchResponse>;
+};
+export {};

package/dist/search-client.js

@@ -0,0 +1,56 @@
+const defaultFetch = (url, init) => fetch(url, init);
+function validateVector(vector) {
+    if (!vector) {
+        return undefined;
+    }
+    if (vector.length === 0 || vector.some((value) => !Number.isFinite(value))) {
+        throw new Error("`vector` must be a non-empty number array.");
+    }
+    return vector;
+}
+export async function searchByVector(input, fetchImpl = defaultFetch) {
+    const endpoint = input.endpoint.trim();
+    if (!endpoint) {
+        throw new Error("`endpoint` is required.");
+    }
+    const payload = {
+        topK: input.topK
+    };
+    const vector = validateVector(input.vector);
+    if (vector) {
+        payload.vector = vector;
+    }
+    if (input.query) {
+        payload.query = input.query;
+    }
+    const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...(input.headers ?? {})
+        },
+        body: JSON.stringify(payload),
+        signal: input.signal
+    });
+    if (!response.ok) {
+        const message = await response.text();
+        throw new Error(`Vector search request failed (${response.status} ${response.statusText}): ${message}`);
+    }
+    const body = (await response.json());
+    return {
+        total: typeof body.total === "number" ? body.total : 0,
+        results: Array.isArray(body.results) ? body.results : []
+    };
+}
+export function createVectorSearchClient(options) {
+    return {
+        search: (input) => searchByVector({
+            ...input,
+            endpoint: options.endpoint,
+            headers: {
+                ...(options.headers ?? {}),
+                ...(input.headers ?? {})
+            }
+        }, options.fetchImpl)
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+export interface CliArgs {
+    targetDir?: string;
+    projectId?: string;
+    region?: string;
+    serviceId?: string;
+    location?: string;
+    documentPath?: string;
+    functionName?: string;
+    installDependencies?: boolean;
+    configFileName?: string;
+    vectorSearch?: Partial<VectorSearchConfig>;
+    addCollection?: boolean;
+    yes: boolean;
+    help: boolean;
+}
+export interface VectorSearchConfig {
+    enabled: boolean;
+    collectionPath: string;
+    sourceTextField: string;
+    vectorField: string;
+    returnFields: string[];
+    functionName: string;
+    defaultTopK: number;
+}
+export interface SetupConfig {
+    targetDir: string;
+    projectId: string;
+    region: string;
+    serviceId: string;
+    location: string;
+    documentPath: string;
+    functionName: string;
+    installDependencies: boolean;
+    configFileName: string;
+    vectorSearch: VectorSearchConfig;
+    existingTargets: SetupTargetConfig[];
+}
+export interface RunResult {
+    targetDir: string;
+    summaryLines: string[];
+}
+export interface SetupTargetConfig {
+    documentPath: string;
+    functionName: string;
+    vectorSearch: VectorSearchConfig;
+}
+export interface PersistedBootstrapConfig {
+    projectId: string;
+    region: string;
+    serviceId: string;
+    location: string;
+    installDependencies: boolean;
+    configFileName: string;
+    targets: SetupTargetConfig[];
+    lastTargetFunctionName?: string;
+}

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "firebase-dataconnect-bootstrap",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Bootstrap Firebase Data Connect and Firestore onDocumentWritten function setup in any repository.",
   "type": "module",
   "bin": {
     "firebase-dataconnect-bootstrap": "bin/firebase-dataconnect-bootstrap.js"
   },
-  "main": "dist/main.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./search-client": {
+      "types": "./dist/search-client.d.ts",
+      "import": "./dist/search-client.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "bin",
     "dist",
@@ -26,7 +38,8 @@
     "dataconnect",
     "firestore",
     "cloud-functions",
-    "cli"
+    "cli",
+    "vector-search"
   ],
   "author": "",
   "license": "MIT",