uql-orm 0.83.1 → 0.85.0

package/README.md

@@ -7,7 +7,7 @@
   </picture>
 </a>
 
-<h3>The JSON-native TypeScript ORM</h3>
+<h3>JSON-native ORM for TypeScript</h3>
 
 <p align="left">UQL queries SQL databases and MongoDB with plain, type-safe JSON-syntax.
 </p>
@@ -121,19 +121,42 @@ const posts = await pool.findMany(Post, {
 
 The result is typed to what the query selected: `posts[0].author?.email` compiles, `posts[0].likes` does not.
 
-### 4. Serve it, and send the same query from the browser
+### 4. Or serve it over HTTP, scoped to the signed-in user
 
 ```ts
 // server.ts: Bun, Deno, Cloudflare Workers, or any framework that takes a fetch handler
+import { defineFilter } from 'uql-orm';
 import { createFetchHandler } from 'uql-orm/http';
-import { Post, User } from './entities.js';
+import { authenticate } from './auth.js';
+import { Post } from './entities.js';
 import { pool } from './uql.config.js';
 
-export default { fetch: createFetchHandler({ pool, include: [User, Post] }) };
+declare module 'uql-orm' {
+  interface UqlContext {
+    userId?: number;
+  }
+}
+
+// Scopes every read and write on Post: no `$where` widens it, a new post gets `authorId`, and with no user it throws.
+defineFilter(Post, 'ownPosts', {
+  where: (ctx) => (ctx?.userId != null ? { authorId: ctx.userId } : undefined),
+  security: true,
+});
+
+export default {
+  fetch: createFetchHandler({
+    pool,
+    include: [Post],
+    // From your verified session, never from client input.
+    getContext: async (request) => ({ userId: (await authenticate(request)).userId }),
+  }),
+};
 ```
 
+The client sends a query as JSON and gets the same typed result, never touching the database:
+
 ```ts
-// browser.ts
+// client.ts
 import { HttpQuerier } from 'uql-orm/browser';
 import { Post } from './entities.js';
 
@@ -141,15 +164,13 @@ const api = new HttpQuerier('https://api.example.com');
 
 const { data: posts } = await api.findMany(Post, {
   $select: { title: true },
-  $populate: { author: { $select: { email: true } } },
   $where: { likes: { $gte: 10 } },
   $sort: { likes: 'desc' },
   $limit: 10,
 });
-// GET /post?$select={"title":true}&$populate={"author":{"$select":{"email":true}}}&$where={"likes":{"$gte":10}}&$sort={"likes":"desc"}&$limit=10
 ```
 
-The query object is the same on both sides, and so is its type check. Authorization goes in the handler's [hooks](https://uql-orm.dev/http#authorization-hooks), and tenant isolation in [security filters](https://uql-orm.dev/multi-tenancy) that apply to every query, including the server's own.
+Only the entities in `include` are served: a `$populate: { author: true }` here is a `400`, as `User` is not. More in [HTTP](https://uql-orm.dev/http) and [multi-tenancy](https://uql-orm.dev/multi-tenancy).
 
 ### When CRUD is not enough
 
@@ -164,7 +185,7 @@ The query object is the same on both sides, and so is its type check. Authorizat
 - **Type-safe to the leaf, nothing to generate.** Every key is checked against your entity, down into populated relations and [JSON/JSONB](https://uql-orm.dev/querying/json) dot-paths, so `$like` on a numeric column is a compile error. No `.prisma` file, no generated client.
 - **Relations without N+1.** [`$populate`](https://uql-orm.dev/querying/relations) reads a to-many inside the parent's statement, so a read is one round trip. Nothing is lazy, so nothing fires behind your back in a serializer.
 - **Light.** Zero runtime dependencies and every dialect in one package, yet `uql-orm/postgres` is about 27 kB gzipped. See [what we deleted to get there](https://uql-orm.dev/blog/zero-dependencies).
-- **The hard things are built in.** [Semantic and vector search](https://uql-orm.dev/ai-semantic-search), [multi-tenant filters you cannot bypass by accident](https://uql-orm.dev/multi-tenancy), [soft-delete with restore](https://uql-orm.dev/entities/soft-delete), [streaming](https://uql-orm.dev/querying/streaming), and [drift checks](https://uql-orm.dev/migrations) that catch a database that no longer matches.
+- **The hard things are built in.** [Semantic and vector search](https://uql-orm.dev/ai-semantic-search), [multi-tenant filters you cannot bypass by accident](https://uql-orm.dev/multi-tenancy), [soft-delete with restore](https://uql-orm.dev/entities/soft-delete), [streaming](https://uql-orm.dev/querying/streaming), [drift checks](https://uql-orm.dev/migrations) that catch a database that no longer matches, and [Better Auth](https://uql-orm.dev/better-auth) on every engine.
 - **The fastest ORM.** On a full PostgreSQL round trip it adds the least over hand-written driver code of any ORM in our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), on Bun, Node and Deno alike. The same benchmark [scores the types](https://github.com/rogerpadilla/ts-orm-benchmark#type-safety) by compiling ordinary mistakes in each ORM's API: UQL is the only one that catches them all.
 
 ## Get started

package/dist/betterAuth/authEntities.d.ts

@@ -0,0 +1,7 @@
+import type { BetterAuthOptions } from 'better-auth';
+import type { Type } from '../type/index.js';
+/**
+ * The entities Better Auth's tables are for these options, its core tables and every plugin's: list them
+ * in `uql.config.ts` so `uql-migrate` creates and migrates them with the rest.
+ */
+export declare function authEntities(options: BetterAuthOptions): Type<object>[];

package/dist/betterAuth/authEntities.js

@@ -0,0 +1,154 @@
+import { getAuthTables } from 'better-auth/db';
+import { defineEntity, defineField, defineId, defineIndex, defineRelation } from '../entity/index.js';
+import { UqlUsageError } from '../util/uqlError.js';
+/**
+ * The entities Better Auth's tables are for these options, its core tables and every plugin's: list them
+ * in `uql.config.ts` so `uql-migrate` creates and migrates them with the rest.
+ */
+export function authEntities(options) {
+    const shapes = shapesOf(options);
+    // A field type that is a constructor keyed by its name, which JSON would drop.
+    const key = JSON.stringify(shapes, (_, value) => (typeof value === 'function' ? value.name : value));
+    let entities = defined.get(key);
+    if (!entities) {
+        entities = defineTables(shapes);
+        defined.set(key, entities);
+    }
+    return [...entities];
+}
+/**
+ * Each set of tables defined so far, by its shapes: kept, since an adapter built on it may still be
+ * reading, and a table defined twice for one shape would be two entities over one table.
+ */
+const defined = new Map();
+/** Defines every table at once, since each one's foreign keys point at the others. */
+function defineTables(shapes) {
+    const byName = Object.fromEntries(shapes.map(({ name }) => [
+        name,
+        {
+            [name]: class {
+            },
+        }[name],
+    ]));
+    for (const { name, id, fields, indexes } of shapes) {
+        const entity = byName[name];
+        defineId(entity, 'id', id);
+        for (const field of fields) {
+            defineField(entity, field.name, field.options);
+            const { references } = field;
+            if (references) {
+                defineRelation(entity, `${field.name}Ref`, {
+                    entity: () => byName[references.table],
+                    cardinality: 'm1',
+                    references: (local, foreign) => [{ local: local[field.name], foreign: foreign[references.column] }],
+                    onDelete: references.onDelete,
+                });
+            }
+        }
+        for (const index of indexes) {
+            defineIndex(entity, { ...index, columns: (refs) => index.columns.map((column) => refs[column]) });
+        }
+        defineEntity(entity, { name });
+    }
+    return Object.values(byName);
+}
+/** Better Auth's schema as the tables UQL defines, every reference resolved to the column it points at. */
+function shapesOf(options) {
+    const schema = getAuthTables(options);
+    const id = keyOf(options);
+    const columnOf = (fields, key) => fields[key]?.fieldName ?? key;
+    // Refused rather than left for the schema build, which drops a foreign key whose column it cannot find.
+    const referenceOf = ({ model, field, onDelete = 'cascade' }) => {
+        const table = schema[model] ?? Object.values(schema).find(({ modelName }) => modelName === model);
+        const column = table?.fields[field];
+        if (!table || (field !== 'id' && !column)) {
+            throw new UqlUsageError(`a Better Auth field references '${model}.${field}', which its schema does not have`);
+        }
+        return {
+            // Every foreign key is indexed, so it takes the type an indexed copy of the column it points at would.
+            type: column ? typeOf({ ...column, index: true }) : id.type,
+            references: {
+                table: table.modelName,
+                column: column ? columnOf(table.fields, field) : 'id',
+                onDelete: ON_DELETE[onDelete],
+            },
+        };
+    };
+    return Object.values(schema).map((table) => ({
+        name: table.modelName,
+        id,
+        fields: Object.entries(table.fields).map(([key, field]) => {
+            const name = columnOf(table.fields, key);
+            const reference = field.references && referenceOf(field.references);
+            return {
+                name,
+                options: {
+                    name,
+                    type: reference?.type ?? typeOf(field),
+                    nullable: field.required === false,
+                    unique: field.unique,
+                    index: field.index,
+                    defaultValue: staticDefault(field),
+                },
+                references: reference?.references,
+            };
+        }),
+        indexes: (table.indexes ?? []).map(({ fields, unique, name }) => ({
+            columns: fields.map((key) => columnOf(table.fields, key)),
+            unique,
+            name,
+        })),
+    }));
+}
+/** The key: Better Auth's own string, its UUID, or the database's number; a key left to the database otherwise is refused. */
+function keyOf(options) {
+    const generateId = options.advanced?.database?.generateId;
+    if (generateId === false) {
+        throw new UqlUsageError("Better Auth's 'generateId: false' leaves the key to the database, which it can generate in more than one " +
+            "way: set 'serial' for a number or 'uuid' for a UUID");
+    }
+    if (generateId === 'serial') {
+        return { type: Number, autoIncrement: true };
+    }
+    return { type: generateId === 'uuid' ? 'uuid' : String };
+}
+/**
+ * A field's column type. Text is `text` unless something indexes it, which a column of unbounded length
+ * cannot be on MySQL; a list of allowed values is text too, since Better Auth checks them itself and a
+ * database check on them would need a migration each time one is added.
+ */
+function typeOf(field) {
+    const { type } = field;
+    if (type === 'string' || Array.isArray(type)) {
+        return field.unique || field.index || field.sortable ? String : 'text';
+    }
+    switch (type) {
+        case 'number':
+            return field.bigint ? BigInt : Number;
+        case 'boolean':
+            return Boolean;
+        case 'date':
+            return Date;
+        case 'json':
+        case 'string[]':
+        case 'number[]':
+            return 'json';
+    }
+}
+/**
+ * The default a column takes in the database, as Better Auth's own migrator gives one: a plain value on a
+ * text, number or boolean field, so a required column added to a populated table has one to backfill. A
+ * nullable unique column gets none, `NULL` being its only backfill two rows can share.
+ */
+function staticDefault({ type, defaultValue, unique, required }) {
+    const plain = typeof defaultValue === 'string' || typeof defaultValue === 'number' || typeof defaultValue === 'boolean';
+    const typed = type === 'string' || type === 'number' || type === 'boolean';
+    return plain && typed && !(unique && required === false) ? defaultValue : undefined;
+}
+const ON_DELETE = {
+    cascade: 'CASCADE',
+    'no action': 'NO ACTION',
+    restrict: 'RESTRICT',
+    'set null': 'SET NULL',
+    'set default': 'SET DEFAULT',
+};

package/dist/betterAuth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './authEntities.js';
+export * from './uqlAdapter.js';

package/dist/betterAuth/index.js

@@ -0,0 +1,2 @@
+export * from './authEntities.js';
+export * from './uqlAdapter.js';

package/dist/betterAuth/uqlAdapter.d.ts

@@ -0,0 +1,16 @@
+import type { BetterAuthOptions } from 'better-auth';
+import { type DBAdapter, type DBAdapterDebugLogOption } from 'better-auth/adapters';
+import type { QuerierPool } from '../type/index.js';
+export type UqlAdapterOptions = {
+    readonly debugLogs?: DBAdapterDebugLogOption;
+    /**
+     * Whether Better Auth runs its multi-step writes in one transaction: on wherever the engine has them,
+     * so off on D1. A standalone MongoDB, which has them only as a replica set, needs `false`.
+     */
+    readonly transaction?: boolean;
+};
+/**
+ * Better Auth on a UQL pool, on every engine UQL runs on: `betterAuth({ database: uqlAdapter(pool) })`.
+ * Its tables are the entities {@link authEntities} returns, which `uql-migrate` creates like any other.
+ */
+export declare function uqlAdapter(pool: QuerierPool, opts?: UqlAdapterOptions): (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;

package/dist/betterAuth/uqlAdapter.js

@@ -0,0 +1,155 @@
+import { createAdapterFactory, } from 'better-auth/adapters';
+import { likeLiteral } from '../dialect/operators.js';
+import { getMeta, idOf } from '../entity/index.js';
+import { whereIds } from '../util/dialect.util.js';
+import { entityName } from '../util/object.util.js';
+import { UqlUsageError } from '../util/uqlError.js';
+import { authEntities } from './authEntities.js';
+/**
+ * Better Auth on a UQL pool, on every engine UQL runs on: `betterAuth({ database: uqlAdapter(pool) })`.
+ * Its tables are the entities {@link authEntities} returns, which `uql-migrate` creates like any other.
+ */
+export function uqlAdapter(pool, opts = {}) {
+    const transactions = opts.transaction ?? pool.dialect.features.transactions;
+    return (options) => {
+        const entities = Object.fromEntries(authEntities(options).map((entity) => [entityName(getMeta(entity)), entity]));
+        const on = (querier, inTransaction) => createAdapterFactory({
+            config: {
+                adapterId: 'uql',
+                adapterName: 'UQL',
+                debugLogs: opts.debugLogs,
+                supportsJSON: true,
+                supportsDates: true,
+                supportsBooleans: true,
+                supportsNumericIds: true,
+                supportsArrays: true,
+                // The same adapter over the transaction's querier, as Better Auth's own adapters rebuild theirs.
+                transaction: transactions && !inTransaction ? (callback) => pool.transaction((trx) => callback(on(trx, true))) : false,
+            },
+            adapter: ({ getFieldName }) => methodsOf(querier, entities, getFieldName),
+        })(options);
+        return on(pool, false);
+    };
+}
+/**
+ * Better Auth's database methods over `querier`, its tables by the names its factory checked each `model`
+ * against. Only `where` arrives in database names; the rest are mapped here.
+ */
+function methodsOf(querier, entities, getFieldName) {
+    const select = (model, fields) => fields?.length ? Object.fromEntries(fields.map((field) => [getFieldName({ model, field }), true])) : undefined;
+    const filter = (where) => ({ $where: whereOf(where) });
+    /**
+     * Writes `payload` to the first row `where` finds, pinned to that row while it still matches `where`,
+     * and reads it back: `null` where none matched, or a concurrent write moved the row past the guard first.
+     */
+    const updateOne = async (model, where, payload) => {
+        const entity = entities[model];
+        const row = await querier.findOne(entity, filter(where));
+        if (!row) {
+            return null;
+        }
+        const meta = getMeta(entity);
+        const id = idOf(meta, row);
+        const pinned = { $where: { $and: [whereOf(where), whereIds(meta, id)] } };
+        const changed = await querier.updateMany(entity, pinned, payload);
+        return changed ? asRow(await querier.findOneById(entity, id)) : null;
+    };
+    return {
+        async create({ model, data }) {
+            const entity = entities[model];
+            const id = await querier.insertOne(entity, data);
+            // The row as stored, which Better Auth's SQL adapters return too: a column left out reads its default.
+            const row = id === undefined ? undefined : await querier.findOneById(entity, id);
+            if (!row) {
+                throw new UqlUsageError(`Better Auth inserted a '${model}' row it cannot read back: does a filter hide it?`);
+            }
+            return asRow(row);
+        },
+        async findOne({ model, modelKey = model, where, select: fields }) {
+            return asRow(await querier.findOne(entities[model], { ...filter(where), $select: select(modelKey, fields) }));
+        },
+        async findMany({ model, modelKey = model, where = [], select: fields, sortBy, offset, limit }) {
+            const rows = await querier.findMany(entities[model], {
+                ...filter(where),
+                $select: select(modelKey, fields),
+                $sort: sortBy && { [getFieldName({ model: modelKey, field: sortBy.field })]: sortBy.direction },
+                $skip: offset,
+                $limit: limit,
+            });
+            return rows.map((row) => asRow(row));
+        },
+        count({ model, where = [] }) {
+            return querier.count(entities[model], filter(where));
+        },
+        update({ model, where, update }) {
+            return updateOne(model, where, payloadOf(update));
+        },
+        // `$inc` adds in the statement, so racing increments all land, where a read-then-write would retry.
+        incrementOne({ model, where, increment, set }) {
+            const steps = Object.fromEntries(Object.entries(increment).map(([field, $inc]) => [field, { $inc }]));
+            return updateOne(model, where, { ...set, ...steps });
+        },
+        updateMany({ model, where, update }) {
+            return querier.updateMany(entities[model], filter(where), update, { unfiltered: !where.length });
+        },
+        async delete({ model, where }) {
+            // Unlike `deleteMany`, never unfiltered: UQL refuses one naming no row.
+            await querier.deleteMany(entities[model], filter(where));
+        },
+        deleteMany({ model, where }) {
+            return querier.deleteMany(entities[model], filter(where), { unfiltered: !where.length });
+        },
+    };
+}
+/**
+ * A row as the type Better Auth asks for, `null` for none: each method lets its caller name the shape of
+ * its own table, which no query can check, so this is the one place UQL takes that on trust.
+ */
+function asRow(row) {
+    return (row ?? null);
+}
+/** An update's payload, which Better Auth types as anything and always sends as a row of fields. */
+function payloadOf(update) {
+    if (typeof update !== 'object' || update === null) {
+        throw new UqlUsageError('Better Auth sent an update that is not a row of fields');
+    }
+    return update;
+}
+/**
+ * Better Auth's clauses as one `$where`: all of those joined by `AND`, and any of those joined by `OR`.
+ * Each clause is an entry of its own, since two on one field would overwrite each other in one map.
+ */
+function whereOf(where) {
+    const all = where.filter((clause) => clause.connector === 'AND').map(clauseOf);
+    const any = where.filter((clause) => clause.connector === 'OR').map(clauseOf);
+    const $where = {};
+    if (all.length)
+        $where['$and'] = all;
+    if (any.length)
+        $where['$or'] = any;
+    return $where;
+}
+/** One clause; ignoring case applies where every value is text, as Better Auth's own adapters hold. */
+function clauseOf({ field, operator, value, mode }) {
+    const values = [value].flat();
+    const texts = mode === 'insensitive' && values.length && values.every((it) => typeof it === 'string') ? values : undefined;
+    return CLAUSES[operator](field, value, texts);
+}
+/** A literal case-insensitive match, which reads the same on every engine. */
+const ilike = (field, text) => ({ [field]: { $ilike: likeLiteral(text) } });
+/** An `in` list without `null`, which no `IN` matches and which makes every `NOT IN` match nothing. */
+const listOf = (value) => [value].flat().filter((it) => it !== null);
+/** Every Better Auth operator as the clause it is; `satisfies` fails the build on one it adds. */
+const CLAUSES = {
+    eq: (field, value, texts) => (texts ? ilike(field, texts[0]) : { [field]: { $eq: value } }),
+    ne: (field, value, texts) => (texts ? { $not: [ilike(field, texts[0])] } : { [field]: { $ne: value } }),
+    lt: (field, value) => ({ [field]: { $lt: value } }),
+    lte: (field, value) => ({ [field]: { $lte: value } }),
+    gt: (field, value) => ({ [field]: { $gt: value } }),
+    gte: (field, value) => ({ [field]: { $gte: value } }),
+    in: (field, value, texts) => texts ? { $or: texts.map((text) => ilike(field, text)) } : { [field]: { $in: listOf(value) } },
+    not_in: (field, value, texts) => texts ? { $nor: texts.map((text) => ilike(field, text)) } : { [field]: { $nin: listOf(value) } },
+    contains: (field, value, texts) => ({ [field]: { [texts ? '$iincludes' : '$includes']: value } }),
+    starts_with: (field, value, texts) => ({ [field]: { [texts ? '$istartsWith' : '$startsWith']: value } }),
+    ends_with: (field, value, texts) => ({ [field]: { [texts ? '$iendsWith' : '$endsWith']: value } }),
+};

package/dist/browser/uql-browser.min.js

@@ -1,4 +1,4 @@
-var c=[];function d(e){for(let r of c)r(e)}function A(e){c.push(e);let r=c.length-1;return()=>{c.splice(r,1)}}var O=["$select","$populate","$exclude","$where","$sort"],f=["$count"],b=["$skip","$limit"],R=["$candidates"],T=["$distinct"],v=["$lock",...f,...R];var C=Symbol("rawValue"),W=Symbol("rawAlias"),B=Symbol("rawText");class i extends TypeError{name="UqlUsageError";kind="usage";status=400}function l(e){return e?Object.keys(e):[]}function k(e){if(typeof e!=="object"||e===null)return!0;if(Array.isArray(e))return!1;let r=Object.getPrototypeOf(e);return r!==Object.prototype&&r!==null}var Z=new Set([...O,...f,...b,...R,...T,"hardDelete","count"]);function u(e){if(!e)return"";let r=new URLSearchParams;for(let n of l(e)){let o=e[n];if(o===void 0)continue;r.append(n,typeof o==="object"&&o!==null?a(o):String(o))}let t=r.toString();return t?`?${t}`:""}function a(e){return JSON.stringify(e,(r,t)=>{if(typeof t!=="object"||t===null)return t;if(C in t)throw new i("raw SQL cannot travel over HTTP: what leaves the browser is JSON");if(t instanceof ArrayBuffer||ArrayBuffer.isView(t))throw new i("binary cannot travel over HTTP: what leaves the browser is JSON");return t})}class K extends Error{status;constructor(e,r){super(e);this.status=r;this.name="RequestError"}}function h(e,r){return y(e,{method:"get"},r)}function x(e,r,t){return y(e,{method:"post",body:a(r)},t)}function Q(e,r,t){return y(e,{method:"patch",body:a(r)},t)}function g(e,r,t){return y(e,{method:"put",body:a(r)},t)}function m(e,r){return y(e,{method:"delete"},r)}function U(e,r,t){return y(e,{method:"QUERY",body:a(r)},t)}function y(e,r,t){if(d({phase:"start",opts:t}),r.headers={accept:"application/json","content-type":"application/json",...t?.headers},t?.signal)r.signal=t.signal;return fetch(e,r).then((n)=>n.json().then((o)=>{if(n.status>=200&&n.status<300)return d({phase:"success",opts:t}),o;let P=o,E={message:P?.error?.message??n.statusText,code:P?.error?.code??n.status};throw d({phase:"error",error:E,opts:t}),new K(E.message,E.code)})).finally(()=>{d({phase:"complete",opts:t})})}function q(e){let r=e.charAt(0).toLowerCase();for(let t=1;t<e.length;++t)r+=e[t]===e[t].toUpperCase()?"-"+e[t].toLowerCase():e[t];return r}var s={findMany:{method:"GET",path:""},findOne:{method:"GET",path:"/one"},count:{method:"GET",path:"/count"},findOneById:{method:"GET",path:"/:id"},insertOne:{method:"POST",path:""},insertMany:{method:"POST",path:"/many"},saveOne:{method:"PUT",path:""},saveMany:{method:"PUT",path:"/many"},updateMany:{method:"PATCH",path:""},updateOneById:{method:"PATCH",path:"/:id"},deleteOneById:{method:"DELETE",path:"/:id"},deleteMany:{method:"DELETE",path:""}},F=l(s),ue=new Map(F.filter((e)=>s[e].method==="GET"&&s[e].path!=="/:id").map((e)=>[s[e].path,e]));function j(e){return q(e.name)}function w(e,r){if(!k(r))throw new i(`'${e.name}' was addressed by an id object, which the HTTP route cannot carry.`);return String(r)}class S{basePath;defaults;constructor(e,r={}){this.basePath=e;this.defaults=r}async findOneById(e,r,t,n){let o=this.getBasePath(e),p=u(t);return h(`${o}/${w(e,r)}${p}`,this.buildOptions(n))}findOne(e,r,t){return this.read(`${this.getBasePath(e)}${s.findOne.path}`,r,t)}findMany(e,r,t){let n={...r};if(t?.count)n.count=!0;return this.read(this.getBasePath(e),n,t)}async findManyAndCount(e,r,t){let n=await this.findMany(e,r,{...t,count:!0});if(typeof n.count!=="number")throw TypeError("findManyAndCount response has an invalid count");return{...n,count:n.count}}count(e,r,t){return this.read(`${this.getBasePath(e)}${s.count.path}`,r,t)}async exists(e,r,t){let n=await this.count(e,{...r,$limit:1},t);return{...n,data:n.data>0}}insertOne(e,r,t){let n=this.getBasePath(e);return x(n,r,this.buildOptions(t))}insertMany(e,r,t){let n=this.getBasePath(e);return x(`${n}${s.insertMany.path}`,r,this.buildOptions(t))}async updateOneById(e,r,t,n){let o=this.getBasePath(e);return Q(`${o}/${w(e,r)}`,t,this.buildOptions(n))}updateMany(e,r,t,n){let o=this.getBasePath(e),p=u(r);return Q(`${o}${p}`,t,this.buildOptions(n))}saveOne(e,r,t){let n=this.getBasePath(e);return g(n,r,this.buildOptions(t))}saveMany(e,r,t){let n=this.getBasePath(e);return g(`${n}${s.saveMany.path}`,r,this.buildOptions(t))}async deleteOneById(e,r,t={}){let n=this.getBasePath(e),o=t.hardDelete?u({hardDelete:t.hardDelete}):"";return m(`${n}/${w(e,r)}${o}`,this.buildOptions(t))}deleteMany(e,r,t={}){let n=this.getBasePath(e),o=u(t.hardDelete?{...r,hardDelete:t.hardDelete}:r);return m(`${n}${o}`,this.buildOptions(t))}getBasePath(e){return`${this.basePath}/${(this.defaults.entityPath??j)(e)}`}read(e,r,t){if(this.defaults.readMethod==="QUERY")return U(e,r??{},this.buildOptions(t));return h(`${e}${u(r)}`,this.buildOptions(t))}buildOptions(e){if(!this.defaults.headers&&!e?.headers)return e;return{...e,headers:{...this.defaults.headers,...e?.headers}}}}var V={getQuerier:()=>new S("/api")};function Re(e){V=e}function _(){return V}function he(){return _().getQuerier()}export{S as HttpQuerier,K as RequestError,h as get,he as getQuerier,_ as getQuerierPool,d as notify,A as on,Q as patch,x as post,g as put,U as query,m as remove,Re as setQuerierPool};
+var c=[];function d(e){for(let r of c)r(e)}function M(e){c.push(e);let r=c.length-1;return()=>{c.splice(r,1)}}var O=["$select","$populate","$exclude","$where","$sort"],f=["$count"],b=["$skip","$limit"],R=["$candidates"],T=["$distinct"],L=["$lock",...f,...R];var C=Symbol("rawValue"),N=Symbol("rawAlias"),D=Symbol("rawText");class k extends Error{}class i extends k{name="UqlUsageError";kind="usage";status=400}function l(e){return e?Object.keys(e):[]}function K(e){if(typeof e!=="object"||e===null)return!0;if(Array.isArray(e))return!1;let r=Object.getPrototypeOf(e);return r!==Object.prototype&&r!==null}var _=["hardDelete","count"],te=new Set([...O,...f,...b,...R,...T,..._]);function u(e){if(!e)return"";let r=new URLSearchParams;for(let n of l(e)){let o=e[n];if(o===void 0)continue;r.append(n,typeof o==="object"&&o!==null?a(o):String(o))}let t=r.toString();return t?`?${t}`:""}function a(e){return JSON.stringify(e,(r,t)=>{if(typeof t!=="object"||t===null)return t;if(C in t)throw new i("raw SQL cannot travel over HTTP: what leaves the browser is JSON");if(t instanceof ArrayBuffer||ArrayBuffer.isView(t))throw new i("binary cannot travel over HTTP: what leaves the browser is JSON");return t})}class U extends Error{status;constructor(e,r){super(e);this.status=r;this.name="RequestError"}}function x(e,r){return y(e,{method:"get"},r)}function h(e,r,t){return y(e,{method:"post",body:a(r)},t)}function Q(e,r,t){return y(e,{method:"patch",body:a(r)},t)}function g(e,r,t){return y(e,{method:"put",body:a(r)},t)}function m(e,r){return y(e,{method:"delete"},r)}function q(e,r,t){return y(e,{method:"QUERY",body:a(r)},t)}function y(e,r,t){if(d({phase:"start",opts:t}),r.headers={accept:"application/json","content-type":"application/json",...t?.headers},t?.signal)r.signal=t.signal;return fetch(e,r).then((n)=>n.json().then((o)=>{if(n.status>=200&&n.status<300)return d({phase:"success",opts:t}),o;let P=o,E={message:P?.error?.message??n.statusText,code:P?.error?.code??n.status};throw d({phase:"error",error:E,opts:t}),new U(E.message,E.code)})).finally(()=>{d({phase:"complete",opts:t})})}function F(e){let r=e.charAt(0).toLowerCase();for(let t=1;t<e.length;++t)r+=e[t]===e[t].toUpperCase()?"-"+e[t].toLowerCase():e[t];return r}var s={findMany:{method:"GET",path:""},findOne:{method:"GET",path:"/one"},count:{method:"GET",path:"/count"},findOneById:{method:"GET",path:"/:id"},insertOne:{method:"POST",path:""},insertMany:{method:"POST",path:"/many"},saveOne:{method:"PUT",path:""},saveMany:{method:"PUT",path:"/many"},updateMany:{method:"PATCH",path:""},updateOneById:{method:"PATCH",path:"/:id"},deleteOneById:{method:"DELETE",path:"/:id"},deleteMany:{method:"DELETE",path:""}},A=l(s),ye=new Map(A.filter((e)=>s[e].method==="GET"&&s[e].path!=="/:id").map((e)=>[s[e].path,e]));function V(e){return F(e.name)}function w(e,r){if(!K(r))throw new i(`'${e.name}' was addressed by an id object, which the HTTP route cannot carry.`);return String(r)}class S{basePath;defaults;constructor(e,r={}){this.basePath=e;this.defaults=r}async findOneById(e,r,t,n){let o=this.getBasePath(e),p=u(t);return x(`${o}/${w(e,r)}${p}`,this.buildOptions(n))}findOne(e,r,t){return this.read(`${this.getBasePath(e)}${s.findOne.path}`,r,t)}findMany(e,r,t){let n={...r};if(t?.count)n.count=!0;return this.read(this.getBasePath(e),n,t)}async findManyAndCount(e,r,t){let n=await this.findMany(e,r,{...t,count:!0});if(typeof n.count!=="number")throw TypeError("findManyAndCount response has an invalid count");return{...n,count:n.count}}count(e,r,t){return this.read(`${this.getBasePath(e)}${s.count.path}`,r,t)}async exists(e,r,t){let n=await this.count(e,{...r,$limit:1},t);return{...n,data:n.data>0}}insertOne(e,r,t){let n=this.getBasePath(e);return h(n,r,this.buildOptions(t))}insertMany(e,r,t){let n=this.getBasePath(e);return h(`${n}${s.insertMany.path}`,r,this.buildOptions(t))}async updateOneById(e,r,t,n){let o=this.getBasePath(e);return Q(`${o}/${w(e,r)}`,t,this.buildOptions(n))}updateMany(e,r,t,n){let o=this.getBasePath(e),p=u(r);return Q(`${o}${p}`,t,this.buildOptions(n))}saveOne(e,r,t){let n=this.getBasePath(e);return g(n,r,this.buildOptions(t))}saveMany(e,r,t){let n=this.getBasePath(e);return g(`${n}${s.saveMany.path}`,r,this.buildOptions(t))}async deleteOneById(e,r,t={}){let n=this.getBasePath(e),o=t.hardDelete?u({hardDelete:t.hardDelete}):"";return m(`${n}/${w(e,r)}${o}`,this.buildOptions(t))}deleteMany(e,r,t={}){let n=this.getBasePath(e),o=u(t.hardDelete?{...r,hardDelete:t.hardDelete}:r);return m(`${n}${o}`,this.buildOptions(t))}getBasePath(e){return`${this.basePath}/${(this.defaults.entityPath??V)(e)}`}read(e,r,t){if(this.defaults.readMethod==="QUERY")return q(e,r??{},this.buildOptions(t));return x(`${e}${u(r)}`,this.buildOptions(t))}buildOptions(e){if(!this.defaults.headers&&!e?.headers)return e;return{...e,headers:{...this.defaults.headers,...e?.headers}}}}var j={getQuerier:()=>new S("/api")};function he(e){j=e}function v(){return j}function Qe(){return v().getQuerier()}export{S as HttpQuerier,U as RequestError,x as get,Qe as getQuerier,v as getQuerierPool,d as notify,M as on,Q as patch,h as post,g as put,q as query,m as remove,he as setQuerierPool};
 
-//# debugId=54F53C9583121D9864756E2164756E21
+//# debugId=20295AB43B909F0564756E2164756E21
 //# sourceMappingURL=uql-browser.min.js.map