backlex 0.1.0

package/dist/types-CbcbXGiA.d.ts

@@ -0,0 +1,247 @@
+/** Comparison operators for a single field (multi-key maps AND together). */
+interface ComparisonObj {
+    _eq?: unknown;
+    _neq?: unknown;
+    _in?: unknown[];
+    _nin?: unknown[];
+    _gt?: unknown;
+    _gte?: unknown;
+    _lt?: unknown;
+    _lte?: unknown;
+    /** Inclusive range: `col BETWEEN lo AND hi`. */
+    _between?: [unknown, unknown];
+    _null?: boolean;
+    _contains?: string;
+    _starts_with?: string;
+    _ends_with?: string;
+    /** Case-insensitive variants (LOWER() both sides → PG/SQLite parity). */
+    _icontains?: string;
+    _istarts_with?: string;
+    _iends_with?: string;
+    /** `_empty: true` ⇒ NULL or empty string; `_nempty: true` ⇒ neither. */
+    _empty?: boolean;
+    _nempty?: boolean;
+}
+/**
+ * Relative-date value usable anywhere a comparison value is expected, e.g.
+ * `{ placed_at: { _gte: { $now: { sub: { months: 1 } } } } }`. Bare `"$now"`
+ * still means "this instant"; resolved server-side to the dialect-correct value.
+ */
+interface RelativeNow {
+    $now: {
+        add?: DurationParts;
+        sub?: DurationParts;
+    };
+}
+interface DurationParts {
+    years?: number;
+    months?: number;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+type Condition = {
+    $and: Condition[];
+} | {
+    $or: Condition[];
+} | {
+    $not: Condition;
+} | {
+    [field: string]: ComparisonObj;
+};
+
+interface ListResponse<T> {
+    data: T[];
+    limit: number;
+    offset: number;
+    meta?: {
+        filter_count?: number;
+        total_count?: number;
+    };
+}
+interface ItemResponse<T> {
+    data: T;
+}
+interface ListQuery {
+    filter?: Condition;
+    sort?: string | string[];
+    fields?: string | string[];
+    /** Inline single-hop relations (replaces the FK with the related object). */
+    expand?: string | string[];
+    limit?: number;
+    offset?: number;
+    meta?: "filter_count" | "total_count" | "*";
+    /** Collapse `i18n_text` fields to one locale, or `"*"` for the full map. */
+    locale?: string;
+    /** Free-text search — `_contains` OR'd across readable text fields. */
+    q?: string;
+    /** Versioned collections only. `published` (default for unprivileged callers)
+     *  returns published items; `draft` / `all` require `publish`/`update`
+     *  permission, otherwise they're ignored and published-only is enforced. */
+    status?: "draft" | "published" | "all";
+}
+/** Per-call options for `from(slug).one(id, ...)`. Mirrors the single-item
+ *  read endpoint, which accepts the same `expand`/`locale` query params as the
+ *  list endpoint. */
+interface ItemQuery {
+    /** Inline single-hop relations (replaces the FK with the related object). */
+    expand?: string | string[];
+    /** Collapse `i18n_text` fields to one locale, or `"*"` for the full map. */
+    locale?: string;
+}
+/** Body for `from(slug).aggregate(...)`. A single function over one column. */
+interface AggregateQuery {
+    agg: "count" | "sum" | "avg" | "min" | "max";
+    /** Target column. Required for sum/avg/min/max; omit (or "*") for count. */
+    field?: string;
+    /** Group by a single column — returns one `{ label, value }` row per group. */
+    groupBy?: string;
+    filter?: Condition;
+    limit?: number;
+}
+/** A row from `aggregate`: `{ value }` ungrouped, or `{ label, value }` grouped. */
+interface AggregateRow {
+    value: number;
+    label?: unknown;
+}
+/** Body for `from(slug).search(...)` — relevance search over a collection. */
+interface SearchQuery {
+    /** The query string. */
+    q: string;
+    /** `fts` = keyword index, `vector` = semantic embeddings, `hybrid` = both
+     *  fused with Reciprocal Rank Fusion. Defaults server-side to `hybrid` when
+     *  both backends are enabled, else whichever single one is. */
+    mode?: "fts" | "vector" | "hybrid";
+    /** Max rows to return (1–100, default 20). */
+    limit?: number;
+    /** Collapse `i18n_text` fields to one locale, or `"*"` for the full map. */
+    locale?: string;
+}
+/** Response from `from(slug).search(...)` — rows ordered best-first. */
+interface SearchResponse<T> {
+    data: T[];
+    /** The mode that actually ran (resolved from the request + collection caps). */
+    mode: "fts" | "vector" | "hybrid";
+    limit: number;
+}
+/** Summary from `from(slug).importItems(...)` — per-row outcome of a bulk
+ *  import. `errors` is capped to the first 50 failures server-side. */
+interface ImportSummary {
+    inserted: number;
+    failed: number;
+    total: number;
+    errors: {
+        row: number;
+        error: string;
+    }[];
+}
+interface ItemEvent<T = Record<string, unknown>> {
+    event: "created" | "updated" | "deleted";
+    data: T;
+}
+type BatchOperation<T = Record<string, unknown>> = {
+    op: "create";
+    data: Partial<T>;
+} | {
+    op: "update";
+    id: string;
+    data: Partial<T>;
+} | {
+    op: "delete";
+    id: string;
+};
+interface BatchRowResult<T = Record<string, unknown>> {
+    index: number;
+    op: "create" | "update" | "delete";
+    ok: boolean;
+    id?: string;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface BatchResponse<T = Record<string, unknown>> {
+    data: {
+        atomic: boolean;
+        total: number;
+        succeeded: number;
+        failed: number;
+        results: BatchRowResult<T>[];
+    };
+}
+interface DeviceToken {
+    id: string;
+    platform: "fcm" | "apns" | "web-push";
+    token: string;
+    deviceName: string | null;
+    isActive: boolean;
+    createdAt: string | number;
+    lastSeenAt: string | number | null;
+}
+interface PhoneNumber {
+    id: string;
+    phoneNumber: string;
+    isActive: boolean;
+    createdAt: string | number;
+    lastSeenAt: string | number | null;
+}
+type JobStatus = "pending" | "active" | "succeeded" | "failed" | "dead_letter" | "cancelled";
+interface Job {
+    id: string;
+    tenantId: string | null;
+    queue: string;
+    type: string;
+    payload: Record<string, unknown>;
+    status: JobStatus;
+    priority: number;
+    runAt: string | number;
+    attempts: number;
+    maxAttempts: number;
+    lastError: string | null;
+    result: unknown;
+    createdAt: string | number;
+    completedAt: string | number | null;
+}
+type UploadStatus = "pending" | "completed" | "aborted";
+/** A resumable (TUS) upload session, as returned by the management API. */
+interface Upload {
+    id: string;
+    key: string;
+    size: number;
+    offset: number;
+    status: UploadStatus;
+    contentType: string | null;
+    folderId: string | null;
+    parts: number;
+    createdAt: string | number;
+    updatedAt: string | number;
+    expiresAt: string | number;
+}
+/** Result of a resumable upload — the final key and the TUS session location. */
+interface ResumableUploadResult {
+    key: string;
+    location: string;
+}
+/** One evaluated feature flag for the calling identity. */
+interface FlagState {
+    enabled: boolean;
+    value: unknown;
+}
+interface ApiError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+declare class BacklexError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details?: unknown;
+    constructor(status: number, body: {
+        error?: ApiError;
+    } | undefined);
+}
+
+export { type AggregateQuery as A, BacklexError as B, type Condition as C, type DeviceToken as D, type FlagState as F, type ImportSummary as I, type Job as J, type ListQuery as L, type PhoneNumber as P, type RelativeNow as R, type SearchQuery as S, type Upload as U, type AggregateRow as a, type ApiError as b, type BatchOperation as c, type BatchResponse as d, type BatchRowResult as e, type DurationParts as f, type ItemEvent as g, type ItemQuery as h, type ItemResponse as i, type JobStatus as j, type ListResponse as k, type ResumableUploadResult as l, type SearchResponse as m, type UploadStatus as n };

package/dist/types.d.ts

@@ -0,0 +1 @@
+export { A as AggregateQuery, a as AggregateRow, b as ApiError, B as BacklexError, c as BatchOperation, d as BatchResponse, e as BatchRowResult, D as DeviceToken, F as FlagState, I as ImportSummary, g as ItemEvent, h as ItemQuery, i as ItemResponse, J as Job, j as JobStatus, L as ListQuery, k as ListResponse, P as PhoneNumber, l as ResumableUploadResult, S as SearchQuery, m as SearchResponse, U as Upload, n as UploadStatus } from './types-CbcbXGiA.js';

package/dist/types.js

@@ -0,0 +1 @@
+export { BacklexError } from './chunk-UIUS57OR.js';

package/dist/webhook.d.ts

@@ -0,0 +1,39 @@
+interface VerifyWebhookOptions {
+    /** The hook's signing secret (the `secret` you configured on the webhook). */
+    secret: string;
+    /** The raw request body, exactly as received — do NOT re-stringify a parsed
+     *  object, or the bytes (and therefore the HMAC) won't match. */
+    body: string;
+    /** The signature header value to check. Pass `X-Backlex-Signature-V2`
+     *  together with `timestamp` for replay protection, or the legacy
+     *  `X-Backlex-Signature` on its own. */
+    signature: string;
+    /** The `X-Backlex-Timestamp` header. When present, the replay-safe V2 scheme
+     *  is verified and the delivery is rejected if the timestamp is too old. */
+    timestamp?: string | number;
+    /** Allowed clock skew for the timestamp, in seconds (default 300). `0`
+     *  disables the freshness check. Ignored when no `timestamp` is supplied. */
+    toleranceSec?: number;
+}
+/**
+ * Verify a backlex webhook delivery's signature.
+ *
+ * Replay-safe path (recommended) — pass the `X-Backlex-Signature-V2` header as
+ * `signature` and the `X-Backlex-Timestamp` header as `timestamp`:
+ *
+ * ```ts
+ * const ok = await verifyWebhook({
+ *   secret,
+ *   body: await req.text(),
+ *   signature: req.headers.get("x-backlex-signature-v2")!,
+ *   timestamp: req.headers.get("x-backlex-timestamp")!,
+ * });
+ * ```
+ *
+ * Legacy path — pass only the `X-Backlex-Signature` header (no replay window).
+ * Returns `false` (never throws) on any missing input, stale timestamp, or
+ * mismatch.
+ */
+declare const verifyWebhook: (opts: VerifyWebhookOptions) => Promise<boolean>;
+
+export { type VerifyWebhookOptions, verifyWebhook };

package/dist/webhook.js

@@ -0,0 +1 @@
+export { verifyWebhook } from './chunk-U2MHWV2E.js';

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "backlex",
+  "version": "0.1.0",
+  "description": "Typed TypeScript client for the backlex API — auth, collection CRUD, query builder, realtime, storage, jobs, flags, and offline sync. Zero dependencies. On npm as compiled ESM + types; on JSR (@backlex/backlex) as TypeScript source.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "homepage": "https://backlex.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/backlex/backlex.git",
+    "directory": "packages/client"
+  },
+  "bugs": "https://github.com/backlex/backlex/issues",
+  "keywords": [
+    "backlex",
+    "backend-as-a-service",
+    "baas",
+    "sdk",
+    "client",
+    "typescript",
+    "rest",
+    "realtime"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./webhook": {
+      "types": "./dist/webhook.d.ts",
+      "default": "./dist/webhook.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}