@flowerforce/flowerbase-client 0.1.1-beta.2

package/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2026 Flowerbase

package/README.md

@@ -0,0 +1,198 @@
+# @flowerforce/flowerbase-client
+
+Client TypeScript leggero per usare Flowerbase con API in stile Realm:
+
+- autenticazione (`local-userpass`, `anon-user`, `custom-function`)
+- chiamate funzioni (`user.functions.<name>(...)`)
+- accesso a MongoDB Atlas service (`user.mongoClient("mongodb-atlas")`)
+- change stream via `watch()` con async iterator
+- supporto BSON/EJSON (`ObjectId`, `Date`, ecc.)
+
+## Installazione
+
+```bash
+npm i @flowerforce/flowerbase-client
+```
+
+## Quick start
+
+```ts
+import { App, Credentials } from '@flowerforce/flowerbase-client'
+
+const app = new App({
+  id: 'my-app-id',
+  baseUrl: 'http://localhost:8000',
+  timeout: 10000
+})
+
+await app.logIn(Credentials.emailPassword('user@example.com', 'secret'))
+
+const user = app.currentUser
+if (!user) throw new Error('User not logged in')
+
+const result = await user.functions.myFunction('hello')
+console.log(result)
+```
+
+## Configurazione `App`
+
+```ts
+new App({
+  id: string,          // app id Flowerbase
+  baseUrl: string,     // URL base backend (es: http://localhost:8000)
+  timeout?: number     // default 10000
+})
+```
+
+## Autenticazione
+
+### Local user/pass
+
+```ts
+await app.logIn(Credentials.emailPassword(email, password))
+```
+
+### Anonymous
+
+```ts
+await app.logIn(Credentials.anonymous())
+```
+
+### Custom function auth
+
+```ts
+await app.logIn(
+  Credentials.function({
+    username: 'demo',
+    pin: '1234'
+  })
+)
+```
+
+### Utility `emailPasswordAuth`
+
+```ts
+await app.emailPasswordAuth.registerUser({ email, password })
+await app.emailPasswordAuth.sendResetPasswordEmail(email)
+await app.emailPasswordAuth.callResetPasswordFunction(email, newPassword, extraArg1, extraArg2)
+await app.emailPasswordAuth.resetPassword({ token, tokenId, password })
+```
+
+## Current user
+
+Dopo il login:
+
+```ts
+const user = app.currentUser
+```
+
+Interfaccia principale:
+
+- `user.id`
+- `user.functions.<functionName>(...args)`
+- `user.mongoClient('mongodb-atlas')`
+- `user.refreshAccessToken()`
+- `user.refreshCustomData()`
+- `user.logOut()`
+
+## Funzioni server
+
+```ts
+const response = await user.functions.calculateScore({ workspaceId: 'w1' })
+```
+
+Le risposte sono normalizzate lato client per gestire payload JSON/EJSON.
+
+## Mongo service
+
+```ts
+const mongo = user.mongoClient('mongodb-atlas')
+const collection = mongo.db('mydb').collection('todos')
+
+const one = await collection.findOne({ done: false })
+const many = await collection.find({ done: false })
+
+await collection.insertOne({ title: 'Task', createdAt: new Date() })
+await collection.updateOne({ title: 'Task' }, { $set: { done: true } })
+await collection.deleteOne({ title: 'Task' })
+```
+
+Metodi disponibili su `collection`:
+
+- `find(query?, options?)`
+- `findOne(query?, options?)`
+- `insertOne(document, options?)`
+- `updateOne(filter, update, options?)`
+- `updateMany(filter, update, options?)`
+- `deleteOne(filter, options?)`
+- `watch(pipeline?, options?)`
+
+## Watch / Change streams
+
+`watch()` restituisce un async iterator con reconnect automatico e metodo `close()`.
+
+```ts
+const stream = collection.watch()
+
+try {
+  for await (const change of stream) {
+    console.log(change)
+  }
+} finally {
+  stream.close()
+}
+```
+
+## BSON / EJSON
+
+Il client esporta anche:
+
+```ts
+import { BSON, EJSON, ObjectId, ObjectID } from '@flowerforce/flowerbase-client'
+```
+
+Il layer Mongo client serializza query/opzioni con EJSON e deserializza le risposte, così tipi BSON come `ObjectId` e `Date` restano coerenti con l'uso Realm-like.
+
+## Sessione
+
+La sessione (`accessToken`, `refreshToken`, `userId`) viene salvata con chiave:
+
+- `flowerbase:<appId>:session`
+
+Storage usato:
+
+- `localStorage` se disponibile (browser)
+- memory store fallback (ambienti senza `localStorage`)
+
+Su bootstrap dell'app viene tentato un refresh automatico dell'access token usando il refresh token salvato.
+
+## Logout
+
+```ts
+await user.logOut()
+```
+
+Invia `DELETE /auth/session` con refresh token e pulisce la sessione locale.
+
+## Tipi esportati
+
+- `AppConfig`
+- `CredentialsLike`
+- `UserLike`
+- `MongoClientLike`
+- `CollectionLike`
+- `WatchAsyncIterator`
+
+## Build e test (workspace)
+
+```bash
+npm run build --workspace @flowerforce/flowerbase-client
+npm run test --workspace @flowerforce/flowerbase-client
+```
+
+Oppure dal package:
+
+```bash
+npm run build
+npm test
+```

package/dist/app.d.ts

@@ -0,0 +1,40 @@
+import { AppConfig, CredentialsLike, ProfileData, SessionData } from './types';
+import { User } from './user';
+export declare class App {
+    readonly id: string;
+    readonly baseUrl: string;
+    readonly timeout: number;
+    private readonly sessionManager;
+    currentUser: User | null;
+    private readonly sessionBootstrapPromise;
+    emailPasswordAuth: {
+        registerUser: (input: {
+            email: string;
+            password: string;
+        }) => Promise<unknown>;
+        sendResetPasswordEmail: (email: string) => Promise<unknown>;
+        callResetPasswordFunction: (email: string, password: string, ...args: unknown[]) => Promise<unknown>;
+        resetPassword: (input: {
+            token: string;
+            tokenId: string;
+            password: string;
+        }) => Promise<unknown>;
+    };
+    constructor(config: AppConfig);
+    private providerUrl;
+    private authUrl;
+    private functionsUrl;
+    private createSession;
+    private bootstrapSessionOnLoad;
+    private ensureSessionBootstrapped;
+    private setLoggedInUser;
+    logIn(credentials: CredentialsLike): Promise<User>;
+    getSessionOrThrow(): SessionData;
+    postProvider<T = unknown>(path: string, body: unknown): Promise<T>;
+    callFunction(name: string, args: unknown[]): Promise<any>;
+    callService(name: string, args: unknown[]): Promise<unknown>;
+    getProfile(): Promise<ProfileData>;
+    refreshAccessToken(): Promise<string>;
+    logoutUser(): Promise<void>;
+}
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAuB,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACnG,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAc7B,qBAAa,GAAG;IACd,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAC/C,WAAW,EAAE,IAAI,GAAG,IAAI,CAAO;IAC/B,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAe;IAEvD,iBAAiB,EAAE;QACjB,YAAY,EAAE,CAAC,KAAK,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QAC9E,sBAAsB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QAC3D,yBAAyB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QACpG,aAAa,EAAE,CAAC,KAAK,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;KACjG,CAAA;gBAEW,MAAM,EAAE,SAAS;IAwB7B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,YAAY;YAIN,aAAa;YASb,sBAAsB;YAkBtB,yBAAyB;YAIzB,eAAe;IAevB,KAAK,CAAC,WAAW,EAAE,eAAe;IAkBxC,iBAAiB;IAQX,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IASlE,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;IAmB1C,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;IAkBzC,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC;IAWlC,kBAAkB;IAoBlB,UAAU;CAgBjB"}

package/dist/app.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const functions_1 = require("./functions");
+const http_1 = require("./http");
+const session_1 = require("./session");
+const user_1 = require("./user");
+const API_PREFIX = '/api/client/v2.0';
+class App {
+    constructor(config) {
+        this.currentUser = null;
+        this.id = config.id;
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.timeout = config.timeout ?? 10000;
+        this.sessionManager = new session_1.SessionManager(this.id);
+        const session = this.sessionManager.get();
+        if (session?.userId) {
+            this.currentUser = new user_1.User(this, session.userId);
+        }
+        this.sessionBootstrapPromise = this.bootstrapSessionOnLoad();
+        this.emailPasswordAuth = {
+            registerUser: ({ email, password }) => this.postProvider('/local-userpass/register', { email, password }),
+            sendResetPasswordEmail: (email) => this.postProvider('/local-userpass/reset/send', { email }),
+            callResetPasswordFunction: (email, password, ...args) => this.postProvider('/local-userpass/reset/call', { email, password, arguments: args }),
+            resetPassword: ({ token, tokenId, password }) => this.postProvider('/local-userpass/reset', { token, tokenId, password })
+        };
+    }
+    providerUrl(path) {
+        return `${this.baseUrl}${API_PREFIX}/app/${this.id}/auth/providers${path}`;
+    }
+    authUrl(path) {
+        return `${this.baseUrl}${API_PREFIX}/auth${path}`;
+    }
+    functionsUrl(path = '/call') {
+        return `${this.baseUrl}${API_PREFIX}/app/${this.id}/functions${path}`;
+    }
+    async createSession(refreshToken) {
+        return (0, http_1.requestJson)({
+            url: this.authUrl('/session'),
+            method: 'POST',
+            bearerToken: refreshToken,
+            timeout: this.timeout
+        });
+    }
+    async bootstrapSessionOnLoad() {
+        const session = this.sessionManager.get();
+        if (!session || typeof localStorage === 'undefined') {
+            return;
+        }
+        try {
+            const result = await this.createSession(session.refreshToken);
+            this.sessionManager.set({
+                ...session,
+                accessToken: result.access_token
+            });
+        }
+        catch {
+            this.sessionManager.clear();
+            this.currentUser = null;
+        }
+    }
+    async ensureSessionBootstrapped() {
+        await this.sessionBootstrapPromise;
+    }
+    async setLoggedInUser(data, profileEmail) {
+        const sessionResult = await this.createSession(data.refresh_token);
+        const session = {
+            accessToken: sessionResult.access_token,
+            refreshToken: data.refresh_token,
+            userId: data.user_id
+        };
+        this.sessionManager.set(session);
+        this.currentUser = new user_1.User(this, data.user_id);
+        if (profileEmail) {
+            this.currentUser.profile = { email: profileEmail };
+        }
+        return this.currentUser;
+    }
+    async logIn(credentials) {
+        if (credentials.provider === 'local-userpass') {
+            const result = await this.postProvider('/local-userpass/login', {
+                username: credentials.email,
+                password: credentials.password
+            });
+            return this.setLoggedInUser(result, credentials.email);
+        }
+        if (credentials.provider === 'anon-user') {
+            const result = await this.postProvider('/anon-user/login', {});
+            return this.setLoggedInUser(result);
+        }
+        const result = await this.postProvider('/custom-function/login', credentials.payload);
+        return this.setLoggedInUser(result);
+    }
+    getSessionOrThrow() {
+        const session = this.sessionManager.get();
+        if (!session) {
+            throw new Error('User is not authenticated');
+        }
+        return session;
+    }
+    async postProvider(path, body) {
+        return (0, http_1.requestJson)({
+            url: this.providerUrl(path),
+            method: 'POST',
+            body,
+            timeout: this.timeout
+        });
+    }
+    async callFunction(name, args) {
+        await this.ensureSessionBootstrapped();
+        const session = this.getSessionOrThrow();
+        const payload = {
+            name,
+            arguments: args
+        };
+        const result = await (0, http_1.requestJson)({
+            url: this.functionsUrl('/call'),
+            method: 'POST',
+            body: payload,
+            bearerToken: session.accessToken,
+            timeout: this.timeout
+        });
+        return (0, functions_1.normalizeFunctionResponse)(result);
+    }
+    async callService(name, args) {
+        await this.ensureSessionBootstrapped();
+        const session = this.getSessionOrThrow();
+        const payload = {
+            name,
+            service: 'mongodb-atlas',
+            arguments: args
+        };
+        return (0, http_1.requestJson)({
+            url: this.functionsUrl('/call'),
+            method: 'POST',
+            body: payload,
+            bearerToken: session.accessToken,
+            timeout: this.timeout
+        });
+    }
+    async getProfile() {
+        await this.ensureSessionBootstrapped();
+        const session = this.getSessionOrThrow();
+        return (0, http_1.requestJson)({
+            url: this.authUrl('/profile'),
+            method: 'GET',
+            bearerToken: session.accessToken,
+            timeout: this.timeout
+        });
+    }
+    async refreshAccessToken() {
+        await this.ensureSessionBootstrapped();
+        const session = this.getSessionOrThrow();
+        try {
+            const result = await this.createSession(session.refreshToken);
+            this.sessionManager.set({
+                ...session,
+                accessToken: result.access_token
+            });
+            return result.access_token;
+        }
+        catch (error) {
+            this.sessionManager.clear();
+            this.currentUser = null;
+            throw error;
+        }
+    }
+    async logoutUser() {
+        const session = this.sessionManager.get();
+        try {
+            if (session) {
+                await (0, http_1.requestJson)({
+                    url: this.authUrl('/session'),
+                    method: 'DELETE',
+                    bearerToken: session.refreshToken,
+                    timeout: this.timeout
+                });
+            }
+        }
+        finally {
+            this.sessionManager.clear();
+            this.currentUser = null;
+        }
+    }
+}
+exports.App = App;

package/dist/bson.d.ts

@@ -0,0 +1,8 @@
+import { EJSON, ObjectId, BSON as RawBSON } from 'bson';
+declare const ObjectID: typeof ObjectId;
+declare const BSON: typeof RawBSON & {
+    ObjectId: typeof ObjectId;
+    ObjectID: typeof ObjectId;
+};
+export { BSON, EJSON, ObjectId, ObjectID };
+//# sourceMappingURL=bson.d.ts.map

package/dist/bson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bson.d.ts","sourceRoot":"","sources":["../src/bson.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,MAAM,CAAA;AAEvD,QAAA,MAAM,QAAQ,iBAAW,CAAA;AACzB,QAAA,MAAM,IAAI;;;CAAqD,CAAA;AAE/D,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA"}

package/dist/bson.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectID = exports.ObjectId = exports.EJSON = exports.BSON = void 0;
+const bson_1 = require("bson");
+Object.defineProperty(exports, "EJSON", { enumerable: true, get: function () { return bson_1.EJSON; } });
+Object.defineProperty(exports, "ObjectId", { enumerable: true, get: function () { return bson_1.ObjectId; } });
+const ObjectID = bson_1.ObjectId;
+exports.ObjectID = ObjectID;
+const BSON = Object.assign({}, bson_1.BSON, { ObjectId: bson_1.ObjectId, ObjectID });
+exports.BSON = BSON;

package/dist/credentials.d.ts

@@ -0,0 +1,7 @@
+import { CredentialsLike } from './types';
+export declare class Credentials {
+    static emailPassword(email: string, password: string): CredentialsLike;
+    static anonymous(): CredentialsLike;
+    static function(payload: Record<string, unknown>): CredentialsLike;
+}
+//# sourceMappingURL=credentials.d.ts.map

package/dist/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../src/credentials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,WAAW;IACtB,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe;IAQtE,MAAM,CAAC,SAAS,IAAI,eAAe;IAMnC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe;CAMnE"}

package/dist/credentials.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+class Credentials {
+    static emailPassword(email, password) {
+        return {
+            provider: 'local-userpass',
+            email,
+            password
+        };
+    }
+    static anonymous() {
+        return {
+            provider: 'anon-user'
+        };
+    }
+    static function(payload) {
+        return {
+            provider: 'custom-function',
+            payload
+        };
+    }
+}
+exports.Credentials = Credentials;

package/dist/functions.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeFunctionResponse: (value: unknown) => any;
+export declare const createFunctionsProxy: (callFunction: (name: string, args: unknown[]) => Promise<unknown>) => Record<string, (...args: unknown[]) => Promise<unknown>>;
+//# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,yBAAyB,UAAW,OAAO,QAWvD,CAAA;AAED,eAAO,MAAM,oBAAoB,iBACjB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,OAAO,CAAC,KAChE,OAAO,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,OAAO,CAAC,CASK,CAAA"}

package/dist/functions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionsProxy = exports.normalizeFunctionResponse = void 0;
+const bson_1 = require("./bson");
+const deserialize = (value) => {
+    if (!value || typeof value !== 'object')
+        return value;
+    return bson_1.EJSON.deserialize(value);
+};
+const normalizeFunctionResponse = (value) => {
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return deserialize(parsed);
+        }
+        catch {
+            return value;
+        }
+    }
+    return deserialize(value);
+};
+exports.normalizeFunctionResponse = normalizeFunctionResponse;
+const createFunctionsProxy = (callFunction) => new Proxy({}, {
+    get: (_, key) => {
+        if (typeof key !== 'string')
+            return undefined;
+        return (...args) => callFunction(key, args);
+    }
+});
+exports.createFunctionsProxy = createFunctionsProxy;

package/dist/http.d.ts

@@ -0,0 +1,15 @@
+export declare class FlowerbaseHttpError extends Error {
+    status: number;
+    payload?: unknown;
+    constructor(message: string, status: number, payload?: unknown);
+}
+type RequestParams = {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    bearerToken?: string;
+    timeout?: number;
+};
+export declare const requestJson: <T = unknown>({ url, method, body, bearerToken, timeout }: RequestParams) => Promise<T>;
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,OAAO,CAAA;gBAEL,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;CAM/D;AAED,KAAK,aAAa,GAAG;IACnB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAA;IACpD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAsBD,eAAO,MAAM,WAAW,6DAMrB,aAAa,KAAG,QAAQ,CAAC,CA6C3B,CAAA"}

package/dist/http.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestJson = exports.FlowerbaseHttpError = void 0;
+class FlowerbaseHttpError extends Error {
+    constructor(message, status, payload) {
+        super(message);
+        this.name = 'FlowerbaseHttpError';
+        this.status = status;
+        this.payload = payload;
+    }
+}
+exports.FlowerbaseHttpError = FlowerbaseHttpError;
+const parseBody = async (response) => {
+    const text = await response.text();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+const timeoutSignal = (timeout = 10000) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    return {
+        signal: controller.signal,
+        clear: () => clearTimeout(timer)
+    };
+};
+const requestJson = async ({ url, method = 'GET', body, bearerToken, timeout }) => {
+    const { signal, clear } = timeoutSignal(timeout);
+    try {
+        const response = await fetch(url, {
+            method,
+            headers: {
+                ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+                ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {})
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal
+        });
+        const payload = await parseBody(response);
+        if (!response.ok) {
+            let parsedErrorMessage = null;
+            if (payload && typeof payload === 'object' && 'error' in payload && typeof payload.error === 'string') {
+                try {
+                    const parsed = JSON.parse(payload.error);
+                    if (parsed && typeof parsed === 'object' && 'message' in parsed && typeof parsed.message === 'string') {
+                        parsedErrorMessage = parsed.message;
+                    }
+                }
+                catch {
+                    parsedErrorMessage = null;
+                }
+            }
+            const message = parsedErrorMessage ||
+                (payload && typeof payload === 'object' && 'message' in payload && typeof payload.message === 'string'
+                    ? payload.message
+                    : null) ||
+                (payload && typeof payload === 'object' && 'error' in payload && typeof payload.error === 'string'
+                    ? payload.error
+                    : null) ||
+                `HTTP ${response.status}`;
+            throw new FlowerbaseHttpError(message, response.status, payload);
+        }
+        return payload;
+    }
+    finally {
+        clear();
+    }
+};
+exports.requestJson = requestJson;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { BSON, EJSON, ObjectId, ObjectID } from './bson';
+export { App } from './app';
+export { User } from './user';
+export { Credentials } from './credentials';
+export { BSON, EJSON, ObjectId, ObjectID };
+export type { AppConfig, CredentialsLike, UserLike, MongoClientLike, CollectionLike, WatchAsyncIterator } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAExD,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA;AAC1C,YAAY,EACV,SAAS,EACT,eAAe,EACf,QAAQ,EACR,eAAe,EACf,cAAc,EACd,kBAAkB,EACnB,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectID = exports.ObjectId = exports.EJSON = exports.BSON = exports.Credentials = exports.User = exports.App = void 0;
+const bson_1 = require("./bson");
+Object.defineProperty(exports, "BSON", { enumerable: true, get: function () { return bson_1.BSON; } });
+Object.defineProperty(exports, "EJSON", { enumerable: true, get: function () { return bson_1.EJSON; } });
+Object.defineProperty(exports, "ObjectId", { enumerable: true, get: function () { return bson_1.ObjectId; } });
+Object.defineProperty(exports, "ObjectID", { enumerable: true, get: function () { return bson_1.ObjectID; } });
+var app_1 = require("./app");
+Object.defineProperty(exports, "App", { enumerable: true, get: function () { return app_1.App; } });
+var user_1 = require("./user");
+Object.defineProperty(exports, "User", { enumerable: true, get: function () { return user_1.User; } });
+var credentials_1 = require("./credentials");
+Object.defineProperty(exports, "Credentials", { enumerable: true, get: function () { return credentials_1.Credentials; } });

package/dist/mongo.d.ts

@@ -0,0 +1,4 @@
+import type { App } from './app';
+import { MongoClientLike } from './types';
+export declare const createMongoClient: (app: App) => MongoClientLike;
+//# sourceMappingURL=mongo.d.ts.map

package/dist/mongo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo.d.ts","sourceRoot":"","sources":["../src/mongo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAEhC,OAAO,EAAkB,eAAe,EAAE,MAAM,SAAS,CAAA;AAoBzD,eAAO,MAAM,iBAAiB,QAAS,GAAG,KAAG,eAwC3C,CAAA"}