@qaecy/cue-sdk 0.0.3 → 0.0.4

package/cue-Cl66hB4E.js

@@ -0,0 +1,346 @@
+import { initializeApp as D } from "firebase/app";
+import { getAuth as S, connectAuthEmulator as C, signInWithEmailAndPassword as v, GoogleAuthProvider as P, OAuthProvider as U, signInWithPopup as T, signInWithCustomToken as O, signOut as j, onAuthStateChanged as K, fetchSignInMethodsForEmail as N, linkWithPopup as R, unlink as q, reauthenticateWithCredential as y, EmailAuthProvider as m, updatePassword as $, linkWithCredential as H, verifyBeforeUpdateEmail as x, sendEmailVerification as L } from "firebase/auth";
+import { getFirestore as b, connectFirestoreEmulator as A, doc as _, collection as o, getDoc as f, setDoc as E, getDocs as u, query as h, where as l, serverTimestamp as W, increment as F, addDoc as z, deleteDoc as B, limit as J } from "firebase/firestore";
+import { nanoid as M } from "nanoid";
+const G = "microsoft.com";
+class Q {
+  _auth;
+  _endpoints;
+  constructor(t, e = !1, r) {
+    this._auth = S(t), this._endpoints = r, e && C(this._auth, r.authEmulatorUrl, {
+      disableWarnings: !0
+    });
+  }
+  async signIn(t, e) {
+    if (t === "password") {
+      if (!e)
+        throw new Error("credentials are required for password sign-in");
+      return (await v(
+        this._auth,
+        e.email,
+        e.password
+      )).user;
+    }
+    const r = t === "google" ? new P() : new U(G);
+    return (await T(this._auth, r)).user;
+  }
+  /** Sign in with a Cue API key */
+  async signInWithApiKey(t, e) {
+    const r = await fetch(this._endpoints.tokenUrl, {
+      method: "GET",
+      headers: {
+        "x-project-id": e,
+        "cue-api-key": t
+      }
+    });
+    if (!r.ok)
+      throw new Error(`Failed to fetch custom token: ${r.statusText}`);
+    const { token: s } = await r.json();
+    return (await O(this._auth, s)).user;
+  }
+  /** Sign out the current user */
+  async signOut() {
+    await j(this._auth);
+  }
+  /** Currently signed-in user, or null if not authenticated */
+  get currentUser() {
+    return this._auth.currentUser;
+  }
+  /** Subscribe to authentication state changes. Returns an unsubscribe function. */
+  onAuthStateChanged(t) {
+    return K(this._auth, t);
+  }
+  /** Get the Firebase ID token for the current user, or null if not authenticated */
+  async getToken(t = !1) {
+    const e = this._auth.currentUser;
+    return e ? e.getIdToken(t) : null;
+  }
+  /** Raw Firebase Auth instance, for advanced use cases */
+  get firebaseAuth() {
+    return this._auth;
+  }
+}
+const V = "/assistant/search", Y = "/triplestore/query";
+class X {
+  constructor(t, e, r, s) {
+    this._auth = t, this._gatewayUrl = e, this.projects = r, this.sync = s;
+  }
+  _auth;
+  _gatewayUrl;
+  projects;
+  sync;
+  async _authHeaders() {
+    return this.getAuthHeaders();
+  }
+  /**
+   * Returns standard authentication headers for the current user.
+   * Useful when calling Cue-backed services directly (e.g. the GIS proxy).
+   */
+  async getAuthHeaders() {
+    const t = await this._auth.getToken();
+    if (!t) throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+    return {
+      Authorization: `Bearer ${t}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Search project documents using natural language.
+   * The user must be authenticated before calling this.
+   */
+  async search(t) {
+    const e = await this._authHeaders(), r = await fetch(`${this._gatewayUrl}${V}`, {
+      method: "POST",
+      headers: e,
+      body: JSON.stringify({
+        term: t.term,
+        projectId: t.projectId,
+        categories: t.categories ?? []
+      })
+    });
+    if (!r.ok)
+      throw new Error(`Search request failed: ${r.status} ${r.statusText}`);
+    return r.json();
+  }
+  /**
+   * Execute a SPARQL query against the project's triplestore.
+   * The user must be authenticated before calling this.
+   */
+  async sparql(t, e) {
+    const r = await this._authHeaders(), s = await fetch(`${this._gatewayUrl}${Y}`, {
+      method: "POST",
+      headers: r,
+      body: JSON.stringify({ query: t, projectId: e })
+    });
+    if (!s.ok)
+      throw new Error(`SPARQL query failed: ${s.status} ${s.statusText}`);
+    return s.json();
+  }
+}
+const w = "projects";
+class Z {
+  constructor(t, e, r = !1, s) {
+    if (this._auth = t, this._db = b(e), r) {
+      const a = s?.firestoreEmulatorHost ?? "localhost", i = s?.firestoreEmulatorPort ?? 8080;
+      A(this._db, a, i);
+    }
+  }
+  _auth;
+  _db;
+  _requireUser() {
+    const t = this._auth.currentUser;
+    if (!t) throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+    return t.uid;
+  }
+  /**
+   * Create a new project. The authenticated user is automatically set as admin, syncer, and member.
+   * Throws if a project with the given ID already exists.
+   */
+  async createProject(t) {
+    const e = this._requireUser(), r = t.id ?? crypto.randomUUID(), s = (/* @__PURE__ */ new Date()).toISOString(), a = { views: [], chatDisabled: !1 }, i = _(o(this._db, w), r);
+    if ((await f(i)).exists())
+      throw new Error(`Project with ID "${r}" already exists.`);
+    const c = {
+      id: r,
+      name: t.name,
+      organizationID: t.organizationID,
+      created: s,
+      lastSync: null,
+      isPublic: !1,
+      members: [e],
+      syncers: [e],
+      admins: [e],
+      alternativeIDs: [r],
+      projectSettings: a
+    };
+    return await E(i, c), c;
+  }
+  /**
+   * List all projects where the authenticated user appears in the members, syncers, or admins array.
+   * Runs three parallel Firestore queries and deduplicates by project ID.
+   */
+  async listProjects() {
+    const t = this._requireUser(), e = o(this._db, w), [r, s, a] = await Promise.all([
+      u(h(e, l("members", "array-contains", t))),
+      u(h(e, l("syncers", "array-contains", t))),
+      u(h(e, l("admins", "array-contains", t)))
+    ]), i = /* @__PURE__ */ new Set(), d = [];
+    for (const c of [r, s, a])
+      for (const k of c.docs) {
+        const p = k.data();
+        i.has(p.id) || (i.add(p.id), d.push(p));
+      }
+    return d;
+  }
+  /** Fetch a single project by ID. Returns null if not found. */
+  async getProject(t) {
+    const e = _(o(this._db, w), t), r = await f(e);
+    return r.exists() ? r.data() : null;
+  }
+  /**
+   * Atomically increments `unitsConsumed` on the top-level `clientSync/{projectId}`
+   * document, creating it if it doesn't exist. Intended for pre-flight checks.
+   */
+  async incrementUnitsConsumed(t, e, r) {
+    if (e <= 0) return;
+    const s = _(this._db, "clientSync", t);
+    await E(s, {
+      unitsConsumed: F(e),
+      lastUpdated: W(),
+      lastUserId: r
+    }, { merge: !0 });
+  }
+}
+const g = "apiKeys";
+class tt {
+  constructor(t, e, r, s, a) {
+    this._auth = t, this._db = b(e), r && A(this._db, s, a);
+  }
+  _auth;
+  _db;
+  _apiKeyDocRef;
+  /** Whether the current user has an active API key. */
+  async hasAPIKey() {
+    const t = this._auth.currentUser?.uid;
+    return t ? this._checkIfUserHasAPIKey(t) : !1;
+  }
+  /** Returns the sign-in methods registered for the current user's email. */
+  async getSignInMethods() {
+    const t = this._auth.currentUser;
+    if (!t?.email) throw new Error("User has no e-mail");
+    return N(this._auth.firebaseAuth, t.email);
+  }
+  /** Builds a human-readable label from a Firebase UserInfo provider entry. */
+  buildProviderLabel(t) {
+    return t.displayName && t.email ? `${t.displayName} (${t.email})` : t.displayName ?? t.email ?? "-";
+  }
+  /** Returns SSO accounts linked to the current user (excludes password). */
+  getSSOAccounts() {
+    const t = this._auth.currentUser;
+    return t ? t.providerData.filter((e) => e.providerId !== "password").map((e) => ({ id: e.providerId, label: this.buildProviderLabel(e) })) : [];
+  }
+  /** Links a Google or Microsoft provider to the current account via popup. Returns the new provider label. */
+  async linkProvider(t) {
+    const e = this._requireUser(), r = t === "google.com" ? new P() : new U(t), a = (await R(e, r)).user.providerData.find(
+      (i) => i.providerId === t
+    );
+    return a ? this.buildProviderLabel(a) : "-";
+  }
+  /** Unlinks a provider from the current account. */
+  async unlinkProvider(t) {
+    await q(this._requireUser(), t);
+  }
+  /** Changes the password. Reauthenticates first. */
+  async updatePassword(t, e) {
+    const r = this._requireUser();
+    if (!r.email) throw new Error("User has no e-mail");
+    await y(
+      r,
+      m.credential(r.email, t)
+    ), await $(r, e);
+  }
+  /** Adds (sets) a password for an account that currently only uses SSO. */
+  async addPassword(t) {
+    const e = this._requireUser();
+    if (!e.email) throw new Error("User has no e-mail");
+    await H(e, m.credential(e.email, t));
+  }
+  /** Requests an e-mail change. Sends a verification e-mail to the new address. */
+  async updateEmail(t, e) {
+    const r = this._requireUser();
+    if (!r.email) throw new Error("User e-mail not available");
+    await y(
+      r,
+      m.credential(r.email, e)
+    ), await x(r, t), await L(r);
+  }
+  /** Creates a new API key for the current user. */
+  async createAPIKey(t) {
+    const e = this._auth.currentUser?.uid;
+    if (!e) throw new Error("User not authenticated");
+    const r = { key: `cue-${M(150)}`, uid: e, expiration: t }, s = o(this._db, g);
+    return this._apiKeyDocRef = await z(s, r), r;
+  }
+  /** Revokes the current user's API key. */
+  async revokeAPIKey() {
+    if (!this._apiKeyDocRef) throw new Error("No API key document reference");
+    await B(this._apiKeyDocRef), this._apiKeyDocRef = void 0;
+  }
+  /** Fetches the current user's existing API key. */
+  async requestAPIKey() {
+    if (!this._apiKeyDocRef) throw new Error("No API key document reference");
+    const t = (await f(this._apiKeyDocRef)).data();
+    return { key: t.key, expiration: t.expiration };
+  }
+  async _checkIfUserHasAPIKey(t) {
+    const e = o(this._db, g), r = h(e, l("uid", "==", t), J(1)), s = await u(r);
+    return s.empty || (this._apiKeyDocRef = s.docs[0].ref), !s.empty;
+  }
+  _requireUser() {
+    const t = this._auth.currentUser;
+    if (!t) throw new Error("Not authenticated");
+    return t;
+  }
+}
+const I = "qaecy-mvp-406413", et = "734737865998", rt = {
+  production: {
+    gatewayUrl: "https://accessors-api-gateway-ueyeemwf2a-oa.a.run.app",
+    tokenUrl: "https://accessors-api-gateway-ueyeemwf2a-oa.a.run.app/token",
+    authEmulatorUrl: "http://localhost:9099",
+    storageEmulatorHost: "localhost",
+    storageEmulatorPort: 9199,
+    firestoreEmulatorHost: "localhost",
+    firestoreEmulatorPort: 8080
+  },
+  emulator: {
+    gatewayUrl: "http://localhost:8093",
+    tokenUrl: "http://localhost:8093/token",
+    authEmulatorUrl: "http://localhost:9099",
+    storageEmulatorHost: "localhost",
+    storageEmulatorPort: 9199,
+    firestoreEmulatorHost: "localhost",
+    firestoreEmulatorPort: 8080
+  }
+};
+class nt {
+  auth;
+  api;
+  profile;
+  _app;
+  _endpoints;
+  _isEmulator;
+  constructor(t) {
+    const e = t.environment ?? "production";
+    this._endpoints = { ...rt[e], ...t.endpoints }, this._isEmulator = e === "emulator", this._app = D({
+      apiKey: t.apiKey,
+      appId: t.appId,
+      measurementId: t.measurementId,
+      authDomain: `${I}.firebaseapp.com`,
+      projectId: I,
+      messagingSenderId: et
+    }), this.auth = new Q(this._app, this._isEmulator, this._endpoints);
+    const r = new Z(this.auth, this._app, this._isEmulator, this._endpoints);
+    this.api = this._buildApi(r), this.profile = new tt(
+      this.auth,
+      this._app,
+      this._isEmulator,
+      this._endpoints.firestoreEmulatorHost,
+      this._endpoints.firestoreEmulatorPort
+    );
+  }
+  /** Override in subclasses to provide a custom CueApi (e.g. with sync). */
+  _buildApi(t) {
+    return new X(this.auth, this._endpoints.gatewayUrl, t);
+  }
+  /** Convenience: get the current user's Firebase ID token */
+  getToken(t = !1) {
+    return this.auth.getToken(t);
+  }
+}
+export {
+  nt as C,
+  X as a,
+  Q as b,
+  tt as c,
+  Z as d
+};

package/index.d.ts

@@ -2,5 +2,6 @@ export { Cue } from './lib/cue';
 export { CueAuth } from './lib/auth';
 export { CueApi } from './lib/api';
 export { CueProjects } from './lib/project';
-export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, ProjectData, ProjectSettings, CreateProjectOptions, SyncOptions, SyncResult, } from './lib/models';
+export { CueProfile } from './lib/profile';
+export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, ProjectData, ProjectSettings, CreateProjectOptions, SyncOptions, SyncResult, ScanOutputRecord, ProfileSSOAccount, APIKeyInfo, APIKeyDoc, } from './lib/models';
 export type { AuthStateListener, Unsubscribe } from './lib/auth';

package/index.js

@@ -1,7 +1,8 @@
-import { f as u, h as a, j as C, k as o } from "./index-CV1OX3eG.js";
+import { C as s, a as u, b as C, c as o, d as r } from "./cue-Cl66hB4E.js";
 export {
-  u as Cue,
-  a as CueApi,
+  s as Cue,
+  u as CueApi,
   C as CueAuth,
-  o as CueProjects
+  o as CueProfile,
+  r as CueProjects
 };

package/lib/api.d.ts

@@ -9,6 +9,11 @@ export declare class CueApi {
     readonly sync?: CueSyncApi | undefined;
     constructor(_auth: CueAuth, _gatewayUrl: string, projects: CueProjects, sync?: CueSyncApi | undefined);
     private _authHeaders;
+    /**
+     * Returns standard authentication headers for the current user.
+     * Useful when calling Cue-backed services directly (e.g. the GIS proxy).
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
     /**
      * Search project documents using natural language.
      * The user must be authenticated before calling this.

package/lib/cue.d.ts

@@ -2,6 +2,7 @@ import { FirebaseApp } from 'firebase/app';
 import { CueAuth } from './auth';
 import { CueApi } from './api';
 import { CueProjects } from './project';
+import { CueProfile } from './profile';
 import { CueEndpoints, CueSdkConfig } from './models';
 /**
  * Main entry point for the QAECY SDK (browser-safe).
@@ -15,6 +16,7 @@ import { CueEndpoints, CueSdkConfig } from './models';
 export declare class Cue {
     readonly auth: CueAuth;
     readonly api: CueApi;
+    readonly profile: CueProfile;
     protected readonly _app: FirebaseApp;
     protected readonly _endpoints: CueEndpoints;
     protected readonly _isEmulator: boolean;

package/lib/models.d.ts

@@ -95,6 +95,21 @@ export interface SyncOptions {
     /** Enable verbose logging */
     verbose?: boolean;
 }
+/** Per-extension cost breakdown returned by {@link CueSyncApi.scanCost}. */
+export interface ScanOutputRecord {
+    /** File extension (without leading dot), e.g. `"pdf"`, `"ifc"`. */
+    ext: string;
+    /** Number of files with this extension. */
+    count: number;
+    /** Share of this extension among supported files (0–100). */
+    percentOfFiltered: number;
+    /** Share of this extension among all files (0–100). */
+    percentOfAll: number;
+    /** Billable units for this extension (e.g. pages for PDFs, rows for spreadsheets). */
+    units: number;
+    /** Total size of files with this extension in megabytes. */
+    sizeMb: number;
+}
 export interface SyncResult {
     /** Number of files successfully synced in this run */
     syncCount: number;
@@ -108,4 +123,19 @@ export interface SyncResult {
     totalSize: number;
     /** Whether any RDF metadata was written */
     rdfWritten: boolean;
+    /** Total billable units consumed across all successfully uploaded files in this run */
+    unitsConsumed: number;
+}
+export interface ProfileSSOAccount {
+    id: string;
+    label: string;
+}
+export interface APIKeyInfo {
+    key: string;
+    expiration: string;
+}
+export interface APIKeyDoc {
+    key: string;
+    uid: string;
+    expiration: string;
 }

package/lib/profile.d.ts

@@ -0,0 +1,36 @@
+import { UserInfo } from 'firebase/auth';
+import { FirebaseApp } from 'firebase/app';
+import { APIKeyDoc, APIKeyInfo, ProfileSSOAccount } from './models';
+import { CueAuth } from './auth';
+export declare class CueProfile {
+    private readonly _auth;
+    private readonly _db;
+    private _apiKeyDocRef?;
+    constructor(_auth: CueAuth, app: FirebaseApp, useEmulator: boolean, emulatorHost: string, emulatorPort: number);
+    /** Whether the current user has an active API key. */
+    hasAPIKey(): Promise<boolean>;
+    /** Returns the sign-in methods registered for the current user's email. */
+    getSignInMethods(): Promise<string[]>;
+    /** Builds a human-readable label from a Firebase UserInfo provider entry. */
+    buildProviderLabel(userInfo: UserInfo): string;
+    /** Returns SSO accounts linked to the current user (excludes password). */
+    getSSOAccounts(): ProfileSSOAccount[];
+    /** Links a Google or Microsoft provider to the current account via popup. Returns the new provider label. */
+    linkProvider(ssoProvider: string): Promise<string>;
+    /** Unlinks a provider from the current account. */
+    unlinkProvider(providerId: string): Promise<void>;
+    /** Changes the password. Reauthenticates first. */
+    updatePassword(currentPassword: string, newPassword: string): Promise<void>;
+    /** Adds (sets) a password for an account that currently only uses SSO. */
+    addPassword(password: string): Promise<void>;
+    /** Requests an e-mail change. Sends a verification e-mail to the new address. */
+    updateEmail(newEmail: string, password: string): Promise<void>;
+    /** Creates a new API key for the current user. */
+    createAPIKey(expiration: string): Promise<APIKeyDoc>;
+    /** Revokes the current user's API key. */
+    revokeAPIKey(): Promise<void>;
+    /** Fetches the current user's existing API key. */
+    requestAPIKey(): Promise<APIKeyInfo>;
+    private _checkIfUserHasAPIKey;
+    private _requireUser;
+}

package/lib/project.d.ts

@@ -18,4 +18,9 @@ export declare class CueProjects {
     listProjects(): Promise<ProjectData[]>;
     /** Fetch a single project by ID. Returns null if not found. */
     getProject(projectId: string): Promise<ProjectData | null>;
+    /**
+     * Atomically increments `unitsConsumed` on the top-level `clientSync/{projectId}`
+     * document, creating it if it doesn't exist. Intended for pre-flight checks.
+     */
+    incrementUnitsConsumed(projectId: string, units: number, userId: string): Promise<void>;
 }

package/lib/sync.d.ts

@@ -2,7 +2,7 @@ import { CueBlobStorage } from 'js-databases';
 import { LocalFile } from 'js-sync-tools';
 import { CueAuth } from './auth';
 import { CueProjects } from './project';
-import { SyncOptions, SyncResult } from './models';
+import { ScanOutputRecord, SyncOptions, SyncResult } from './models';
 export declare class CueSyncApi {
     private readonly _auth;
     private readonly _projects;
@@ -17,5 +17,13 @@ export declare class CueSyncApi {
     private _listRemoteFiles;
     private _getGraphFiles;
     private _uploadRdfMetadata;
+    /**
+     * Scans `localFiles` and returns a per-extension cost breakdown.
+     *
+     * Each {@link ScanOutputRecord} contains `units` — the billable metric for
+     * that extension (e.g. pages for PDFs, rows for spreadsheets) — which can be
+     * shown to the user before or after calling {@link sync}.
+     */
+    scanCost(localFiles: LocalFile[]): Promise<ScanOutputRecord[]>;
     private _logProgress;
 }