@bunbase-ae/js 2.13.3-next.288.cbcf81c → 2.13.3-next.304.484953e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunbase-ae/js",
-  "version": "2.13.3-next.288.cbcf81c",
+  "version": "2.13.3-next.304.484953e",
   "type": "module",
   "description": "TypeScript/JavaScript SDK for BunBase",
   "license": "UNLICENSED",

package/src/admin.ts

@@ -650,23 +650,25 @@ class AdminCollectionsClient {
     if (opts.includeDeleted) params.include_deleted = "true";
     if (opts.search) params.search = opts.search;
     if (opts.filter) {
+      // Encode filters as a single ?filter=[{field,op,value}, …] JSON array.
+      // See buildQueryString in collection.ts for the rationale (issue #533):
+      // the bracket form silently corrupts values containing commas.
+      const fieldFilters: { field: string; op: string; value: unknown }[] = [];
       for (const [key, value] of Object.entries(opts.filter)) {
         if (value === undefined || value === null) continue;
-        if (typeof value === "object" && !Array.isArray(value)) {
-          // Operator filter: { age: { gte: 18 } } → filter[age][gte]=18
+        if (Array.isArray(value)) {
+          fieldFilters.push({ field: key, op: "in", value });
+        } else if (typeof value === "object") {
           for (const [op, opVal] of Object.entries(value as Record<string, unknown>)) {
             if (opVal !== undefined && opVal !== null) {
-              params[`filter[${key}][${op}]`] = String(opVal);
+              fieldFilters.push({ field: key, op, value: opVal });
             }
           }
-        } else if (Array.isArray(value)) {
-          // Array shorthand: { stage: ["a", "b"] } → filter[stage][in]=a,b
-          params[`filter[${key}][in]`] = value.join(",");
         } else {
-          // Equality filter: { status: "active" } → filter[status]=active
-          params[`filter[${key}]`] = String(value);
+          fieldFilters.push({ field: key, op: "eq", value });
         }
       }
+      if (fieldFilters.length) params.filter = JSON.stringify(fieldFilters);
     }
     return this.http.request<AdminListResult<T & AdminRecord>>(
       "GET",
@@ -1179,6 +1181,84 @@ class AdminNamedQueriesClient {
   }
 }
 
+// ─── Write hooks ──────────────────────────────────────────────────────────────
+
+export type HookEvent =
+  | "beforeCreate"
+  | "afterCreate"
+  | "beforeUpdate"
+  | "afterUpdate"
+  | "beforeDelete"
+  | "afterDelete";
+
+export interface HookConfig {
+  id: string;
+  collection: string;
+  event: HookEvent;
+  handler_url: string;
+  /** True when a signing secret is configured. Secret value is write-only. */
+  has_handler_secret: boolean;
+  timeout_ms: number;
+  enabled: boolean;
+  sort_order: number;
+  created_at: number;
+}
+
+export interface CreateHookInput {
+  collection: string;
+  event: HookEvent;
+  handler_url: string;
+  /** Optional HMAC-SHA256 signing secret. Write-only — never returned. */
+  handler_secret?: string | null;
+  /** Per-call timeout. Default 5000. */
+  timeout_ms?: number;
+  /** When false, the hook is skipped at delivery time. Default true. */
+  enabled?: boolean;
+  /** Ascending order for hooks sharing the same (collection, event). Default 0. */
+  sort_order?: number;
+}
+
+export type UpdateHookInput = Partial<Omit<CreateHookInput, "collection" | "event">>;
+
+class AdminHooksClient {
+  constructor(private readonly http: HttpClient) {}
+
+  async list(opts?: { collection?: string }): Promise<HookConfig[]> {
+    const params: Record<string, string> = {};
+    if (opts?.collection) params.collection = opts.collection;
+    const res = await this.http.request<{ items: HookConfig[] }>("GET", "/api/v1/admin/hooks", {
+      query: params,
+    });
+    return res.items;
+  }
+
+  async get(id: string): Promise<HookConfig | null> {
+    try {
+      return await this.http.request<HookConfig>(
+        "GET",
+        `/api/v1/admin/hooks/${encodeURIComponent(id)}`,
+      );
+    } catch (err) {
+      if (err instanceof BunBaseError && err.status === 404) return null;
+      throw err;
+    }
+  }
+
+  async create(input: CreateHookInput): Promise<HookConfig> {
+    return this.http.request<HookConfig>("POST", "/api/v1/admin/hooks", { body: input });
+  }
+
+  async update(id: string, patch: UpdateHookInput): Promise<HookConfig> {
+    return this.http.request<HookConfig>("PATCH", `/api/v1/admin/hooks/${encodeURIComponent(id)}`, {
+      body: patch,
+    });
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.http.request("DELETE", `/api/v1/admin/hooks/${encodeURIComponent(id)}`);
+  }
+}
+
 // Tenant membership management — surfaces the /api/v1/admin/tenants/* endpoints
 // added in v2.5.2 (#277/#323) so operators don't need to hand-roll fetch calls
 // to onboard a tenant member.
@@ -1243,6 +1323,7 @@ export class AdminClient {
   readonly backups: AdminBackupsClient;
   readonly migrations: AdminMigrationsClient;
   readonly queries: AdminNamedQueriesClient;
+  readonly hooks: AdminHooksClient;
   readonly logs: AdminLogsClient;
   readonly system: AdminSystemClient;
   readonly tenants: AdminTenantsClient;
@@ -1257,6 +1338,7 @@ export class AdminClient {
     this.backups = new AdminBackupsClient(http);
     this.migrations = new AdminMigrationsClient(http);
     this.queries = new AdminNamedQueriesClient(http);
+    this.hooks = new AdminHooksClient(http);
     this.logs = new AdminLogsClient(http);
     this.system = new AdminSystemClient(http);
     this.tenants = new AdminTenantsClient(http);

package/src/collection.ts

@@ -161,24 +161,28 @@ export function buildQueryString<T extends Record<string, unknown> = Record<stri
   const params: Record<string, string> = {};
 
   if (query.filter) {
+    // Encode filters as a single ?filter=[{field,op,value}, …] JSON array.
+    // The bracket form (?filter[field][op]=value) joins array values on ",", which
+    // silently corrupts any value containing a comma — see issue #533. The JSON
+    // form preserves array values verbatim and is parsed by the server's
+    // parseFilterJson (apps/server/src/routes/_filterParams.ts).
+    const fieldFilters: { field: string; op: string; value: unknown }[] = [];
     for (const [field, value] of Object.entries(query.filter)) {
       if (value === undefined || value === null) continue;
 
-      if (typeof value === "object" && !Array.isArray(value)) {
-        // Operator filter: { age: { gte: 18 } } → filter[age][gte]=18
+      if (Array.isArray(value)) {
+        fieldFilters.push({ field, op: "in", value });
+      } else if (typeof value === "object") {
         for (const [op, opVal] of Object.entries(value as Record<string, unknown>)) {
           if (opVal !== undefined && opVal !== null) {
-            params[`filter[${field}][${op}]`] = String(opVal);
+            fieldFilters.push({ field, op, value: opVal });
           }
         }
-      } else if (Array.isArray(value)) {
-        // Array shorthand: { stage: ["a", "b"] } → filter[stage][in]=a,b
-        params[`filter[${field}][in]`] = value.join(",");
       } else {
-        // Equality filter: { status: "published" } → filter[status]=published
-        params[`filter[${field}]`] = String(value);
+        fieldFilters.push({ field, op: "eq", value });
       }
     }
+    if (fieldFilters.length) params.filter = JSON.stringify(fieldFilters);
   }
 
   if (query.sort) params.sort = query.sort;

package/src/types.ts

@@ -166,8 +166,10 @@ export type FilterFieldValue<V> = V | FilterArrayShorthandValue<V> | FilterOpera
  * filter: { rfid_tag: { in: ["a", "b"] } }
  * filter: { score: { gte: 0, lte: 100 } }
  */
-// Simple: { status: "published" }  → filter[status]=published
-// Operator: { age: { gte: 18 } }  → filter[age][gte]=18
+// Wire format: a single ?filter=[{field,op,value}, …] JSON entry.
+// Simple   { status: "published" }   → [{ field: "status", op: "eq", value: "published" }]
+// Operator { age: { gte: 18 } }      → [{ field: "age", op: "gte", value: 18 }]
+// Array    { id: ["a", "b"] }        → [{ field: "id", op: "in", value: ["a", "b"] }]
 export type Filter<T = Record<string, unknown>> = {
   [K in Exclude<keyof T, keyof BunBaseRecord>]?: FilterFieldValue<T[K]>;
 } & {