@aurabase/aurabase-js 0.3.0

package/packages/db/dist/index.cjs

@@ -0,0 +1,544 @@
+'use strict';
+
+var core = require('@aurabase/core');
+
+// src/DatabaseService.ts
+function quoteReserved(v) {
+  const s = String(v);
+  return /[,()"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+function encodeFilterValue(op, value) {
+  if (op === "in" || op === "not.in") {
+    const arr = Array.isArray(value) ? value : [value];
+    return `${op}.(${arr.map(quoteReserved).join(",")})`;
+  }
+  if (op === "cs" || op === "cd" || op === "ov") {
+    if (Array.isArray(value)) return `${op}.{${value.map(quoteReserved).join(",")}}`;
+    if (value !== null && typeof value === "object") return `${op}.${JSON.stringify(value)}`;
+    return `${op}.${value}`;
+  }
+  if (op.endsWith("(all)") || op.endsWith("(any)")) {
+    const arr = Array.isArray(value) ? value : [value];
+    return `${op}.{${arr.map(quoteReserved).join(",")}}`;
+  }
+  return `${op}.${value}`;
+}
+var PGRST_OBJECT_ACCEPT = "application/vnd.pgrst.object+json";
+function mentionsZeroRows(err) {
+  if (!err) return false;
+  const details = typeof err.details === "string" ? err.details : JSON.stringify(err.details ?? "");
+  return /\b0 rows\b/.test(`${err.message ?? ""} ${details}`);
+}
+function pgrst116(zeroRows) {
+  return new core.AuraError(406, {
+    error: {
+      code: "PGRST116",
+      message: zeroRows ? "JSON object requested, 0 rows returned" : "JSON object requested, multiple rows returned"
+    }
+  });
+}
+var AuraPostgrestBuilder = class {
+  _client;
+  _basePath;
+  _filters = [];
+  _orGroups = [];
+  _selectColumns = null;
+  // `select()` a-t-il été appelé ? (distinct de `_selectColumns`, que `select('*')`
+  // remet à `null`) — sert à poser `Prefer: return=representation` sur une mutation
+  // même avec `select('*')`.
+  _selectInvoked = false;
+  _sortColumn = null;
+  _sortDirection = "asc";
+  _limit = null;
+  _offset = null;
+  _cursor = null;
+  _count = null;
+  _rawSelect = false;
+  _single = false;
+  _maybeSingle = false;
+  _throwOnError = false;
+  _mutation = null;
+  _rpc = null;
+  constructor(client, basePath) {
+    this._client = client;
+    this._basePath = basePath;
+  }
+  throwOnError() {
+    this._throwOnError = true;
+    return this;
+  }
+  /**
+   * Positionne l'état interne `rpc` (args + verbe HTTP) — méthode package-interne
+   * utilisée par `DatabaseService.rpc()` pour éviter un cast sur un champ `protected`.
+   *
+   * `count` accepte `'planned'` (parité stricte `RpcOptions`, cf. `DatabaseService.rpc`)
+   * en plus de `CountMode` (`@aurabase/core`, qui ne connaît que `exact`/`estimated` —
+   * package partagé, non modifié ici). Le cast vers `_count` reste sans risque runtime :
+   * `buildQueryString` sérialise la valeur telle quelle en query param `count=`.
+   */
+  _initRpc(args, verb, count) {
+    this._rpc = { args, verb };
+    if (count) this._count = count;
+    return this;
+  }
+  // -- Query string builder ---------------------------------------------------
+  buildQueryString() {
+    const params = new URLSearchParams();
+    if (this._selectColumns && this._selectColumns.length > 0) {
+      params.set("select", this._rawSelect ? this._selectColumns[0] : this._selectColumns.join(","));
+    }
+    for (const f of this._filters) {
+      params.append(f.column, encodeFilterValue(f.op, f.value));
+    }
+    for (const group of this._orGroups) {
+      const parts = group.filters.map((f) => `${f.column}.${encodeFilterValue(f.op, f.value)}`);
+      params.append("or", `(${parts.join(",")})`);
+    }
+    if (this._sortColumn) {
+      params.set("sort_by", this._sortColumn);
+      params.set("sort_order", this._sortDirection);
+    }
+    if (this._limit !== null) params.set("limit", String(this._limit));
+    if (this._offset !== null) params.set("offset", String(this._offset));
+    if (this._cursor !== null) params.set("cursor", this._cursor);
+    if (this._count) params.set("count", this._count);
+    if (this._rpc && (this._rpc.verb === "GET" || this._rpc.verb === "HEAD") && this._rpc.args && typeof this._rpc.args === "object") {
+      for (const [k, v] of Object.entries(this._rpc.args)) {
+        params.set(k, typeof v === "string" ? v : JSON.stringify(v));
+      }
+    }
+    return params.toString();
+  }
+  // -- Execution via PromiseLike ----------------------------------------------
+  then(onfulfilled, onrejected) {
+    return this._execute().then(onfulfilled, onrejected);
+  }
+  async _execute() {
+    let res;
+    const acceptSingle = this._single ? { Accept: PGRST_OBJECT_ACCEPT } : void 0;
+    if (this._rpc) {
+      const qs = this.buildQueryString();
+      const sep = qs ? "?" : "";
+      const url = `${this._client.baseUrl}${this._basePath}${sep}${qs}`;
+      const init = this._rpc.verb === "POST" ? { method: "POST", body: this._rpc.args, headers: acceptSingle } : { method: this._rpc.verb, headers: acceptSingle };
+      res = await core.fetchWithAuth(url, init, this._client);
+    } else if (this._mutation) {
+      const m = this._mutation;
+      const hasEffectiveFilter = this._filters.some((f) => f.column !== "") || this._orGroups.some((g) => g.filters.length > 0);
+      if ((m.type === "update" || m.type === "delete") && m.id === null && !hasEffectiveFilter) {
+        return {
+          data: null,
+          error: new core.AuraError(0, {
+            error: {
+              code: "unfiltered_mutation",
+              message: "update()/delete() sans filtre refus\xE9 (protection anti-wipe) \u2014 ajoutez un filtre .eq()/... ou utilisez une mutation id-based"
+            }
+          })
+        };
+      }
+      const prefer = [];
+      if (this._selectInvoked) prefer.push("return=representation");
+      if (this._count) prefer.push(`count=${this._count}`);
+      const merged = { ...acceptSingle };
+      if (prefer.length > 0) merged.Prefer = prefer.join(", ");
+      const headers = Object.keys(merged).length > 0 ? merged : void 0;
+      const qs = this.buildQueryString();
+      const sep = qs ? "?" : "";
+      switch (m.type) {
+        case "insert": {
+          res = await core.fetchWithAuth(
+            `${this._client.baseUrl}${this._basePath}${sep}${qs}`,
+            { method: "POST", body: m.body, headers },
+            this._client
+          );
+          break;
+        }
+        case "update": {
+          const path = m.id !== null ? `${this._basePath}/${m.id}` : this._basePath;
+          res = await core.fetchWithAuth(
+            `${this._client.baseUrl}${path}${sep}${qs}`,
+            { method: "PATCH", body: m.body, headers },
+            this._client
+          );
+          break;
+        }
+        case "delete": {
+          const path = m.id !== null ? `${this._basePath}/${m.id}` : this._basePath;
+          res = await core.fetchWithAuth(
+            `${this._client.baseUrl}${path}${sep}${qs}`,
+            { method: "DELETE", headers },
+            this._client
+          );
+          break;
+        }
+        case "upsert": {
+          const params = new URLSearchParams(qs);
+          params.set("on_conflict", m.onConflict);
+          res = await core.fetchWithAuth(
+            `${this._client.baseUrl}${this._basePath}?${params.toString()}`,
+            { method: "POST", body: m.body, headers },
+            this._client
+          );
+          break;
+        }
+      }
+    } else {
+      const qs = this.buildQueryString();
+      const sep = qs ? "?" : "";
+      res = await core.fetchWithAuth(
+        `${this._client.baseUrl}${this._basePath}${sep}${qs}`,
+        { method: "GET", headers: acceptSingle },
+        this._client
+      );
+    }
+    if (!this._single && (this._mutation?.type === "insert" || this._mutation?.type === "upsert") && res.data !== null && typeof res.data === "object" && !Array.isArray(res.data)) {
+      res = { ...res, data: [res.data] };
+    }
+    if (this._single) {
+      if (res.error) {
+        const zero = res.error.status === 406 ? mentionsZeroRows(res.error) : res.error.status === 404 && res.error.code === "RECORD_NOT_FOUND" ? true : null;
+        if (zero !== null) {
+          res = this._maybeSingle && zero ? { ...res, data: null, error: null } : { ...res, data: null, error: pgrst116(zero) };
+        }
+      } else if (Array.isArray(res.data)) {
+        const rows = res.data;
+        if (this._maybeSingle) {
+          res = rows.length > 1 ? { ...res, data: null, error: pgrst116(false) } : { ...res, data: rows[0] ?? null };
+        } else if (rows.length === 1) {
+          res = { ...res, data: rows[0] };
+        } else {
+          res = { ...res, data: null, error: pgrst116(rows.length === 0) };
+        }
+      }
+    }
+    if (this._throwOnError && res.error) {
+      const err = new Error(res.error.message);
+      err.code = res.error.code;
+      err.details = res.error.details;
+      throw err;
+    }
+    return res;
+  }
+};
+var AuraTransformBuilder = class extends AuraPostgrestBuilder {
+  // -- Column selection & resource embedding -----------------------------------
+  /**
+   * Select columns and optionally embed related resources (PostgREST parity).
+   *
+   * @example
+   * // Simple columns
+   * db.from('users').select('id, name, email')
+   *
+   * // All columns (default)
+   * db.from('users').select('*')
+   *
+   * // Embed related table (many-to-one)
+   * db.from('orders').select('*, customer:customers(name, email)')
+   *
+   * // Embed related table (one-to-many)
+   * db.from('directors').select('last_name, films(title, year)')
+   *
+   * // FK disambiguation
+   * db.from('orders').select('*, billing:addresses!billing_address_id(name)')
+   *
+   * // Nested embedding
+   * db.from('actors').select('first_name, roles(character, films(title))')
+   */
+  select(columns) {
+    this._selectInvoked = true;
+    const cols = columns;
+    if (cols === void 0 || cols === "*") {
+      this._selectColumns = null;
+      this._rawSelect = false;
+    } else if (typeof cols === "string") {
+      if (cols.includes("(")) {
+        this._selectColumns = [cols];
+        this._rawSelect = true;
+      } else {
+        this._selectColumns = cols.split(",").map((c) => c.trim());
+        this._rawSelect = false;
+      }
+    } else {
+      this._selectColumns = cols;
+      this._rawSelect = false;
+    }
+    return this;
+  }
+  // -- Sort / pagination ------------------------------------------------------
+  order(column, direction = "asc") {
+    this._sortColumn = column;
+    this._sortDirection = direction;
+    return this;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  offset(n) {
+    this._offset = n;
+    return this;
+  }
+  /**
+   * Pagination keyset : passer le `next_cursor` opaque de la page précédente (préférable à
+   * `offset` sur les grandes tables : stable, sans dup/skip). Renvoyer tel quel `meta.next_cursor` ;
+   * ne pas le construire/parser (format opaque).
+   */
+  cursor(cursor) {
+    this._cursor = cursor;
+    return this;
+  }
+  count(mode = "exact") {
+    this._count = mode;
+    return this;
+  }
+  // -- Modifiers --------------------------------------------------------------
+  single() {
+    this._single = true;
+    return this;
+  }
+  maybeSingle() {
+    this._single = true;
+    this._maybeSingle = true;
+    return this;
+  }
+};
+var AuraFilterBuilder = class extends AuraTransformBuilder {
+  // -- Filter methods (each returns this for chaining) ------------------------
+  //
+  // Typées sur `Row` : `column` est contraint à `keyof Row & string` (autocomplete +
+  // erreur de compilation sur colonne inconnue) et `value`/`values` à `Row[C]` (erreur
+  // sur mauvais type). Runtime inchangé — seules les signatures changent.
+  eq(column, value) {
+    this._filters.push({ column, op: "eq", value });
+    return this;
+  }
+  neq(column, value) {
+    this._filters.push({ column, op: "neq", value });
+    return this;
+  }
+  gt(column, value) {
+    this._filters.push({ column, op: "gt", value });
+    return this;
+  }
+  gte(column, value) {
+    this._filters.push({ column, op: "gte", value });
+    return this;
+  }
+  lt(column, value) {
+    this._filters.push({ column, op: "lt", value });
+    return this;
+  }
+  lte(column, value) {
+    this._filters.push({ column, op: "lte", value });
+    return this;
+  }
+  like(column, pattern) {
+    this._filters.push({ column, op: "like", value: pattern });
+    return this;
+  }
+  ilike(column, pattern) {
+    this._filters.push({ column, op: "ilike", value: pattern });
+    return this;
+  }
+  /**
+   * IS NULL or IS NOT NULL filter.
+   * PostgREST accepts: is.null, is.true, is.false (no "not_null" — use neq for that).
+   * For IS NOT NULL, use `neq(column, null)` or `is(column, 'not.null')`.
+   */
+  is(column, value) {
+    if (value === "not.null") {
+      this._filters.push({ column, op: "not.is", value: "null" });
+    } else {
+      this._filters.push({ column, op: "is", value });
+    }
+    return this;
+  }
+  in(column, values) {
+    this._filters.push({ column, op: "in", value: values });
+    return this;
+  }
+  /**
+   * Add an OR group: `or=(col1.eq.val1,col2.gt.val2)`
+   */
+  or(filters) {
+    this._orGroups.push({
+      filters: filters.map((f) => ({ column: f.column, op: f.op, value: f.value }))
+    });
+    return this;
+  }
+  // -- Filtres étendus (parité PostgREST) -------------------------------------
+  notIn(column, values) {
+    this._filters.push({ column, op: "not.in", value: values });
+    return this;
+  }
+  contains(column, value) {
+    this._filters.push({ column, op: "cs", value });
+    return this;
+  }
+  containedBy(column, value) {
+    this._filters.push({ column, op: "cd", value });
+    return this;
+  }
+  overlaps(column, value) {
+    this._filters.push({ column, op: "ov", value });
+    return this;
+  }
+  rangeGt(column, range) {
+    this._filters.push({ column, op: "sr", value: range });
+    return this;
+  }
+  rangeGte(column, range) {
+    this._filters.push({ column, op: "nxl", value: range });
+    return this;
+  }
+  rangeLt(column, range) {
+    this._filters.push({ column, op: "sl", value: range });
+    return this;
+  }
+  rangeLte(column, range) {
+    this._filters.push({ column, op: "nxr", value: range });
+    return this;
+  }
+  rangeAdjacent(column, range) {
+    this._filters.push({ column, op: "adj", value: range });
+    return this;
+  }
+  isDistinct(column, value) {
+    this._filters.push({ column, op: "isdistinct", value });
+    return this;
+  }
+  // Échappatoires (parité postgrest-js) : colonne `string` permissive, pas de contrainte sur `Row`.
+  not(column, op, value) {
+    this._filters.push({ column, op: `not.${op}`, value });
+    return this;
+  }
+  filter(column, op, value) {
+    this._filters.push({ column, op, value });
+    return this;
+  }
+  match(query) {
+    for (const [column, value] of Object.entries(query)) this._filters.push({ column, op: "eq", value });
+    return this;
+  }
+  textSearch(column, query, options) {
+    const t = options?.type;
+    const token = t === "plain" ? "plfts" : t === "phrase" ? "phfts" : t === "websearch" ? "wfts" : "fts";
+    const op = options?.config ? `${token}(${options.config})` : token;
+    this._filters.push({ column, op, value: query });
+    return this;
+  }
+  likeAllOf(column, patterns) {
+    this._filters.push({ column, op: "like(all)", value: patterns });
+    return this;
+  }
+  likeAnyOf(column, patterns) {
+    this._filters.push({ column, op: "like(any)", value: patterns });
+    return this;
+  }
+  ilikeAllOf(column, patterns) {
+    this._filters.push({ column, op: "ilike(all)", value: patterns });
+    return this;
+  }
+  ilikeAnyOf(column, patterns) {
+    this._filters.push({ column, op: "ilike(any)", value: patterns });
+    return this;
+  }
+};
+var AuraQueryBuilder = class extends AuraFilterBuilder {
+  // -- Mutations --------------------------------------------------------------
+  //
+  // Typées sur `Relation['Insert']`/`Relation['Update']` (parité postgrest-js) :
+  // un champ requis manquant côté insert/upsert, ou une colonne inconnue côté
+  // update, est une erreur de compilation. Runtime inchangé.
+  //
+  // Extraction par type conditionnel (plutôt qu'un accès indexé direct
+  // `Relation['Insert']`) : `Relation` est contraint à `GenericTable | GenericView`
+  // et `GenericNonUpdatableView` ne porte pas `Insert`/`Update`. `infer` distribue
+  // sur cette union et retombe sur `never` pour la branche non-updatable, ce qui
+  // évite l'erreur TS2536 tout en gardant le typage strict pour les tables.
+  insert(body) {
+    this._mutation = { type: "insert", body };
+    return this;
+  }
+  update(idOrBody, body) {
+    if (typeof idOrBody === "string") {
+      this._mutation = { type: "update", id: idOrBody, body };
+    } else {
+      this._mutation = { type: "update", id: null, body: idOrBody };
+    }
+    return this;
+  }
+  // COMPAT `delete(id)` → route id-based ; FILTRÉ `delete()` → route Table
+  // (exige un filtre, garde-fou anti-wipe).
+  delete(id) {
+    this._mutation = { type: "delete", id: typeof id === "string" ? id : null };
+    return this;
+  }
+  upsert(body, options) {
+    this._mutation = { type: "upsert", body, onConflict: options?.onConflict ?? "id" };
+    return this;
+  }
+};
+
+// src/DatabaseService.ts
+var DatabaseService = class extends core.BaseService {
+  constructor(client) {
+    super(client);
+  }
+  get prefix() {
+    return `/v1/db/${this.client.projectId}`;
+  }
+  from(table) {
+    return new AuraQueryBuilder(this.client, `${this.prefix}/${table}`);
+  }
+  /**
+   * Exécute une requête SQL brute (passthrough direct vers Postgres).
+   *
+   * ⚠️ N'est PAS en lecture seule : SELECT, INSERT, UPDATE, DELETE et DDL
+   * s'exécutent réellement et persistent, dans la limite des GRANTs du rôle
+   * Postgres connecté pour ce projet (seule barrière de sécurité — il n'y a
+   * aucun filtre applicatif par type d'instruction côté serveur). Ne pas
+   * exposer cet endpoint sans restriction à des clients non fiables.
+   */
+  async sql(query, params) {
+    return this.request("POST", `${this.prefix}/raw`, { query, params });
+  }
+  /**
+   * Appelle une fonction Postgres exposée par PostgREST (`POST|GET|HEAD /rpc/{fn}`).
+   * Signature forte quand `Schema['Functions']` connaît `fn` (typage vendoré
+   * `GetRpcFunctionFilterBuilderByArgs`, parité postgrest-js) ; sinon repli permissif.
+   *
+   * @example
+   * const { data } = await db.rpc('add', { a: 1, b: 2 })
+   * const { data } = await db.rpc('list_things', {}).eq('id', 2).select('id,name').single()
+   */
+  rpc(fn, args, options) {
+    const verb = options?.head ? "HEAD" : options?.get ? "GET" : "POST";
+    const builder = new AuraFilterBuilder(
+      this.client,
+      `${this.prefix}/rpc/${fn}`
+    )._initRpc(args ?? {}, verb, options?.count);
+    return builder;
+  }
+  /**
+   * Fetch the schema (tables & colonnes, fonctions Postgres exposées via PostgREST,
+   * types enum et vues) pour le projet courant.
+   */
+  async schema() {
+    const res = await this.request("GET", `${this.prefix}/schema`);
+    if (res.error) return { data: null, error: res.error, meta: res.meta };
+    return {
+      data: {
+        tables: res.data?.tables ?? [],
+        functions: res.data?.functions ?? [],
+        enums: res.data?.enums ?? [],
+        views: res.data?.views ?? []
+      },
+      error: null,
+      meta: res.meta
+    };
+  }
+};
+
+exports.DatabaseService = DatabaseService;
+exports.QueryBuilder = AuraQueryBuilder;