@aurabase/aurabase-js 0.3.0

package/packages/db/node_modules/.bin/vitest

@@ -0,0 +1,22 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules/vitest/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules/vitest/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"
+else
+  exec node  "$basedir/../vitest/vitest.mjs" "$@"
+fi
+# cmd-shim-target=/Users/affanedaylami/aurabase/aurabase-js/packages/db/node_modules/vitest/vitest.mjs

package/packages/db/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.9","results":[[":tests/single.test.ts",{"duration":1128.5402080000003,"failed":false}],[":tests/filters.test.ts",{"duration":9.051457999999911,"failed":false}],[":tests/order.test.ts",{"duration":16.057416999999987,"failed":false}],[":tests/schema.test.ts",{"duration":752.6503750000002,"failed":false}],[":tests/types/schema-shape.test-d.ts",{"duration":0,"failed":false}],[":tests/types/select-inference.test-d.ts",{"duration":0,"failed":false}],[":tests/types/filters.test-d.ts",{"duration":0,"failed":false}],[":tests/types/mutations.test-d.ts",{"duration":0,"failed":false}],[":tests/rpc.test.ts",{"duration":1077.0271250000005,"failed":false}],[":tests/types/rpc.test-d.ts",{"duration":0,"failed":false}],[":tests/scale/scale-compile.test.ts",{"duration":18075.547792,"failed":false}],[":tests/vendored/get-result.test-d.ts",{"duration":0,"failed":false}],[":tests/mutations-filtered.test.ts",{"duration":1143.7555410000004,"failed":false}],[":tests/mutations-filtered.e2e.test.ts",{"duration":0,"failed":false}],[":tests/single-accept.e2e.test.ts",{"duration":0,"failed":false}],[":tests/types/from-views.test-d.ts",{"duration":0,"failed":false}]]}

package/packages/db/package.json

@@ -0,0 +1,62 @@
+{
+  "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/db/src/DatabaseService.ts

@@ -0,0 +1,170 @@
+import { BaseService } from '@aurabase/core'
+import type { AuraResponse, SchemaTable, SchemaFunction, SchemaEnum, AuraClientLike } from '@aurabase/core'
+import { AuraQueryBuilder, AuraFilterBuilder } from './QueryBuilder'
+import type { AuraClientOptionsT } from './QueryBuilder'
+import type { GenericSchema } from './pgrst-types/common/common'
+import type { GetRpcFunctionFilterBuilderByArgs } from './pgrst-types/common/rpc'
+
+export interface RpcOptions {
+  count?: 'exact' | 'planned' | 'estimated'
+  head?: boolean
+  get?: boolean
+}
+
+// -- rpc() : typage vendoré (Schema['Functions']) + repli permissif -----------
+//
+// Signature UNIQUE (pas de 2 surcharges séparées) : la borne du paramètre `args`
+// se calcule à partir de `Schema['Functions'][FnName]` — connue → Args strict
+// (erreur de compilation sur un mauvais type d'argument) ; inconnue / Functions
+// vide (`Record<string, never>`, valeur indexée = `never`) / Database non typé
+// (`Schema = any`) → Args permissif (`Record<string, unknown>`).
+//
+// Un design classique à 2 surcharges (forte + `fn: string` fourre-tout) a été
+// essayé et rejeté : vérifié empiriquement (cf. rapport de tâche), TypeScript
+// retombe SILENCIEUSEMENT sur la surcharge permissive dès qu'un mauvais type
+// d'argument est passé à une fonction connue — la 2e surcharge, structurellement
+// compatible (elle accepte n'importe quel objet), absorbe l'appel sans erreur ;
+// le `@ts-expect-error` du type-test devient alors "unused" (aucune erreur réelle
+// détectée). Le calcul conditionnel ci-dessous produit le même comportement
+// observable (fort si connu, permissif sinon) sans ce trou.
+type RpcArgsFor<Schema extends GenericSchema, FnName extends string> = [
+  Schema['Functions'][FnName],
+] extends [never]
+  ? Record<string, unknown>
+  : FnName extends keyof Schema['Functions']
+    ? Schema['Functions'][FnName]['Args']
+    : Record<string, unknown>
+
+type RpcResultFor<Schema extends GenericSchema, FnName extends string, Args> = [
+  Schema['Functions'][FnName],
+] extends [never]
+  ? { Row: any; Result: any; RelationName: any; Relationships: any }
+  : FnName extends string & keyof Schema['Functions']
+    ? GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args>
+    : { Row: any; Result: any; RelationName: any; Relationships: any }
+
+export class DatabaseService<
+  Database = any,
+  Schema extends GenericSchema = Database extends { public: infer S }
+    ? S extends GenericSchema
+      ? S
+      : any
+    : any,
+> extends BaseService {
+  constructor(client: AuraClientLike) {
+    super(client)
+  }
+
+  private get prefix(): string {
+    return `/v1/db/${this.client.projectId}`
+  }
+
+  /**
+   * Start a query on a table. Returns a chainable QueryBuilder dont `.select()`
+   * infère son type de résultat via `GetResult` (parité PostgREST/Supabase) quand
+   * un `Database` typé est fourni à `createClient<Database>()`.
+   *
+   * @example
+   * const { data, error } = await db.from('posts').eq('published', true).limit(10)
+   */
+  from<TableName extends string & keyof Schema['Tables'], Table extends Schema['Tables'][TableName]>(
+    table: TableName,
+  ): AuraQueryBuilder<Schema, Table, TableName, AuraClientOptionsT>
+  // COMPL LOT 4 : `from()` accepte aussi les Views (générées par LOT C). Surcharge
+  // dédiée (pattern postgrest-js) → `Relation` est résolu depuis `Schema['Views']`.
+  // `GenericView` (union updatable/non-updatable) : une vue non updatable ne porte
+  // pas `Insert`/`Update` → `insert()/update()/upsert()` retombent sur `never`
+  // (typage strict, cf. AuraQueryBuilder), seule la lecture (`select`) est offerte.
+  from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(
+    view: ViewName,
+  ): AuraQueryBuilder<Schema, View, ViewName, AuraClientOptionsT>
+  // Repli non typé (Database = any) : conserve le comportement historique permissif.
+  from(table: string): AuraQueryBuilder<any, any, any, AuraClientOptionsT>
+  from(table: string): AuraQueryBuilder<any, any, any, AuraClientOptionsT> {
+    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<T = unknown>(query: string, params?: unknown[]): Promise<AuraResponse<T>> {
+    return this.request<T>('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<
+    FnName extends string,
+    Args extends RpcArgsFor<Schema, FnName> = RpcArgsFor<Schema, FnName>,
+    Fn extends { Row: any; Result: any; RelationName: any; Relationships: any } = RpcResultFor<
+      Schema,
+      FnName,
+      Args
+    >,
+  >(
+    fn: FnName,
+    args?: Args,
+    options?: RpcOptions,
+  ): AuraFilterBuilder<Schema, Fn['Row'], Fn['RelationName'], Fn['Relationships'], Fn['Result'], AuraClientOptionsT> {
+    const verb: 'POST' | 'GET' | 'HEAD' = options?.head ? 'HEAD' : options?.get ? 'GET' : 'POST'
+    const builder = new AuraFilterBuilder<any, any, any, any, any, AuraClientOptionsT>(
+      this.client,
+      `${this.prefix}/rpc/${fn}`,
+    )._initRpc(args ?? {}, verb, options?.count)
+    return builder as AuraFilterBuilder<
+      Schema,
+      Fn['Row'],
+      Fn['RelationName'],
+      Fn['Relationships'],
+      Fn['Result'],
+      AuraClientOptionsT
+    >
+  }
+
+  /**
+   * Fetch the schema (tables & colonnes, fonctions Postgres exposées via PostgREST,
+   * types enum et vues) pour le projet courant.
+   */
+  async schema(): Promise<
+    AuraResponse<{
+      tables: SchemaTable[]
+      functions: SchemaFunction[]
+      enums: SchemaEnum[]
+      views: SchemaTable[]
+    }>
+  > {
+    // Le backend renvoie un SchemaDefinition `{ project_id, engine, tables, functions,
+    // enums, views }` (LOT B). `enums`/`views` sont absents pour les adapters NoSQL et
+    // les backends antérieurs → repli `[]` (rétrocompat).
+    const res = await this.request<{
+      tables?: SchemaTable[]
+      functions?: SchemaFunction[]
+      enums?: SchemaEnum[]
+      views?: SchemaTable[]
+    }>('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,
+    }
+  }
+}