@aurabase/aurabase-js 0.3.1 → 0.4.0

package/packages/db/dist/index.js

@@ -1,541 +0,0 @@
-import { BaseService, fetchWithAuth, AuraError } from '@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 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 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 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 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 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 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 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 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 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
-    };
-  }
-};
-
-export { DatabaseService, AuraQueryBuilder as QueryBuilder };

package/packages/db/package.json

@@ -1,62 +0,0 @@
-{
-  "name": "@aurabase/db",
-  "version": "0.3.0",
-  "description": "Service base de données du SDK Aurabase : query builder typé PostgREST-like + inférence de types",
-  "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "license": "MIT",
-  "author": "Aurabase",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/daylami555/aurabase.git",
-    "directory": "aurabase-js/packages/db"
-  },
-  "homepage": "https://github.com/daylami555/aurabase/tree/main/aurabase-js/packages/db#readme",
-  "bugs": {
-    "url": "https://github.com/daylami555/aurabase/issues"
-  },
-  "keywords": [
-    "aurabase",
-    "baas",
-    "sdk",
-    "database",
-    "query"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run --passWithNoTests && tsc --noEmit -p tsconfig.test-d.json",
-    "test:types": "tsc --noEmit -p tsconfig.test-d.json",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@aurabase/core": "workspace:*"
-  },
-  "devDependencies": {
-    "tsup": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:"
-  }
-}

package/packages/functions/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Aurabase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.