@zuzjs/flare 0.2.17 → 0.2.19

package/README.md

@@ -509,6 +509,241 @@ const boards = await app
 
 Tip: If your join alias is `team`, define `dataMapper.team` (not `dataMapper.users`) for that join payload.
 
+### Storage API (S3-like)
+
+```ts
+import { connectApp, FlareStorageSignedAction } from '@zuzjs/flare';
+
+const app = connectApp({
+  endpoint: 'https://flare.zuzcdn.net',
+  appId: 'my-app',
+  apiKey: 'ak',
+  storage: {
+    /**
+     * Built-in transfer manager — serialises uploads/downloads so calling
+     * putObject / getObject without `await` is always safe.
+     */
+    transferManager: {
+      enabled: true,
+      uploadConcurrency: 1,   // one upload at a time (default)
+      downloadConcurrency: 2, // allow two parallel downloads
+    },
+  },
+});
+
+const storage = app.storage();
+
+await storage.createBucket('avatars');
+
+// ── Raw binary upload (default) ──────────────────────────────────────────────
+// By default putObject uploads files via a signed URL as raw binary.
+// This is efficient for any file size and provides upload progress in browsers.
+const uploaded = await storage.putObject({
+  bucket: 'avatars',
+  key: 'users/alice.png',
+  body: fileOrBlobOrBytes,
+  contentType: 'image/png',
+  onProgress: (p) => {
+    console.log(`uploaded ${p.loaded}/${p.total} (${p.percent}%)`);
+  },
+});
+
+// ── Base64 upload (opt-in, small files only) ─────────────────────────────────
+// Pass `base64: true` to use the legacy base64-over-JSON path.
+// If the payload exceeds `base64MaxBytes` (default 4 MiB), the SDK
+// automatically falls back to raw signed-URL upload.
+const uploaded2 = await storage.putObject({
+  bucket: 'avatars',
+  key: 'users/thumb.png',
+  body: smallFileBytes,
+  contentType: 'image/png',
+  base64: true,         // prefer base64 path
+  base64MaxBytes: 2 * 1024 * 1024, // cap at 2 MiB; larger → raw upload
+});
+
+// ── Pre-encoded base64 (always uses base64 path) ─────────────────────────────
+const uploaded3 = await storage.putObject({
+  bucket: 'avatars',
+  key: 'users/icon.png',
+  contentBase64: alreadyEncodedString,
+  contentType: 'image/png',
+});
+
+const head = await storage.headObject({ bucket: 'avatars', key: uploaded.key });
+const file = await storage.getObject({ bucket: 'avatars', key: uploaded.key });
+
+const page1 = await storage.listObjects({ bucket: 'avatars', prefix: 'users/', limit: 100 });
+const page2 = page1.cursor
+  ? await storage.listObjects({ bucket: 'avatars', prefix: 'users/', limit: 100, cursor: page1.cursor })
+  : { objects: [] };
+
+await storage.copyObject({
+  sourceBucket: 'avatars',
+  sourceKey: 'users/alice.png',
+  destBucket: 'avatars-backup',
+  destKey: 'users/alice.png',
+});
+
+await storage.deleteObjects({
+  bucket: 'avatars',
+  keys: ['users/alice.png', 'users/bob.png'],
+});
+
+const signedUpload = await storage.createSignedUrl({
+  bucket: 'media',
+  key: 'uploads/clip.mp4',
+  action: FlareStorageSignedAction.Upload,
+  expiresInSeconds: 300,
+  contentType: 'video/mp4',
+  encrypt: true,
+});
+
+await fetch(signedUpload.url, {
+  method: signedUpload.method,
+  headers: { 'Content-Type': 'video/mp4' },
+  body: videoBlob,
+});
+```
+
+Direct helpers are also available on the app instance:
+
+```ts
+await app.createBucket('files');
+await app.putObject({ bucket: 'files', key: 'docs/readme.txt', body: 'hello' });
+const doc = await app.getObject({ bucket: 'files', key: 'docs/readme.txt' });
+await app.deleteObject({ bucket: 'files', key: 'docs/readme.txt' });
+
+const signedDownload = await app.createSignedUrl({
+  bucket: 'files',
+  key: 'docs/readme.txt',
+  action: FlareStorageSignedAction.Download,
+  expiresInSeconds: 120,
+});
+
+console.log('signed url expires at unix seconds', signedDownload.expiresAt);
+console.log('signed url ttl seconds', signedDownload.expiresInSeconds);
+```
+
+### Signed URL Download Policies
+
+`token` (for example `st_...`) is only a ticket identifier. Expiry is enforced server-side and returned via `expiresAt` / `expiresInSeconds`.
+
+```ts
+import { connectApp, FlareStorageSignedAction } from '@zuzjs/flare';
+
+const app = connectApp({ endpoint: 'https://flare.zuzcdn.net', appId: 'my-app', apiKey: 'ak' });
+const storage = app.storage();
+
+const signed = await storage.createSignedUrl({
+  bucket: 'media',
+  key: 'videos/intro.mp4',
+  action: FlareStorageSignedAction.Download,
+  expiresInSeconds: 180,
+  forceDownload: true,
+  allowedOrigins: ['https://app.example.com'],
+  embedOnly: false,
+});
+
+console.log(signed.url, signed.expiresAt, signed.expiresInSeconds);
+```
+
+Helper APIs:
+
+```ts
+// 1) Get a direct signed download URL.
+const url = await storage.getObjectUrl({
+  bucket: 'media',
+  key: 'images/hero.png',
+  expiresInSeconds: 90,
+  allowedOrigins: ['*'],
+});
+
+// 2) Trigger browser download (defaults to forceDownload: true).
+await storage.downloadObject({
+  bucket: 'media',
+  key: 'images/hero.png',
+  filename: 'hero.png',
+  expiresInSeconds: 90,
+  allowedOrigins: ['https://app.example.com'],
+  forceDownload: true,
+});
+
+// 3) Embed-only URL for media tags (<img>, <video>, <audio>).
+const embedUrl = await storage.getObjectUrl({
+  bucket: 'media',
+  key: 'videos/trailer.mp4',
+  embedOnly: true,
+  allowedOrigins: ['https://app.example.com'],
+});
+```
+
+Notes:
+- `forceDownload` and `embedOnly` are mutually exclusive.
+- `allowedOrigins` defaults to `['*']` when omitted.
+- `embedOnly` is valid only for download signed URLs.
+
+### Transfer Manager
+
+The built-in transfer manager queues uploads and downloads so fire-and-forget calls
+remain safe without needing a manual `await` at the call site.
+
+```ts
+const app = connectApp({
+  endpoint: 'https://flare.zuzcdn.net',
+  appId: 'my-app',
+  apiKey: 'ak',
+  storage: {
+    transferManager: {
+      enabled: true,
+      uploadConcurrency: 1,   // default — uploads are serialised
+      downloadConcurrency: 2, // allow two downloads in parallel
+    },
+  },
+});
+
+const storage = app.storage();
+
+// All three uploads are queued and executed one at a time — no race conditions.
+storage.putObject({ bucket: 'files', key: 'a.png', body: blobA });
+storage.putObject({ bucket: 'files', key: 'b.png', body: blobB });
+storage.putObject({ bucket: 'files', key: 'c.png', body: blobC });
+
+// Or await them individually for ordered results.
+const [resA, resB] = await Promise.all([
+  storage.putObject({ bucket: 'files', key: 'a.png', body: blobA }),
+  storage.putObject({ bucket: 'files', key: 'b.png', body: blobB }),
+]);
+console.log(resA.key, resB.key);
+```
+
+### External AWS SDK Init From Flare `/aws` Config
+
+  bucket: 'media',
+  key: 'uploads/clip.mp4',
+import { connectApp } from '@zuzjs/flare';
+
+const app = connectApp({ endpoint: 'https://flare.zuzcdn.net', appId: 'my-app', apiKey: 'ak' });
+
+const aws = await app.getStorageServerAwsConfig('storage-server-id');
+
+const s3 = new S3Client({
+  endpoint: aws.endpoint,
+  region: aws.region,
+  forcePathStyle: Boolean(aws.forcePathStyle),
+  credentials: {
+    accessKeyId: aws.accessKeyId,
+    secretAccessKey: aws.secretAccessKey,
+  },
+});
+
+await s3.send(new PutObjectCommand({
+  Bucket: aws.bucket,
+  Key: `${aws.prefix ?? ''}manual/test.txt`,
+  Body: 'hello from external sdk',
+  ContentType: 'text/plain',
+}));
+```
+
 ### Template-Based Email APIs
 
 ### Security Rules Example (Boards Owner Or Team Member)

package/dist/grpc.d.cts

@@ -1,4 +1,4 @@
-import { F as FlareConfig, ad as StructuredQuery } from './index-BAvE1URE.cjs';
+import { F as FlareConfig, aN as StructuredQuery } from './index-Y0Mq_6P9.cjs';
 import '@zuzjs/auth';
 
 declare function runGrpcQuery<T = Record<string, unknown>>(config: FlareConfig, collection: string, query: StructuredQuery): Promise<T[] | null>;

package/dist/grpc.d.ts

@@ -1,4 +1,4 @@
-import { F as FlareConfig, ad as StructuredQuery } from './index-BAvE1URE.js';
+import { F as FlareConfig, aN as StructuredQuery } from './index-Y0Mq_6P9.js';
 import '@zuzjs/auth';
 
 declare function runGrpcQuery<T = Record<string, unknown>>(config: FlareConfig, collection: string, query: StructuredQuery): Promise<T[] | null>;

package/dist/{index-B8jyF1xs.d.ts → index-EwoU5mWk.d.cts}

@@ -1,4 +1,4 @@
-import { an as WhereCondition, af as SubscriptionCallback, Z as QueryConfig, v as DocUpdatedCallback, u as DocDeletedCallback, t as DocChangedCallback, $ as QueryPresetMap, a0 as QueryPresetParams, a1 as QueryPresetRow, a as AggregateSpec, N as HavingClause, O as JoinClause, al as VectorSearchClause, ad as StructuredQuery, aj as SubscriptionHandle, o as CollectionStreamOptions, l as CollectionStream, k as CollectionExternalStore, s as DocAddedCallback, F as FlareConfig, ae as SubscribeOptions, ai as SubscriptionErrorCallback, ah as SubscriptionError, p as ConnectionState, U as PresenceCallback, V as PresenceJoinCallback, W as PresenceLeaveCallback, ak as VectorFieldConfig, a2 as QueryPresetSpec, y as FlareAuthConfig, f as AuthStateListener, d as AuthConfigListener, J as FlareAuthSession, K as FlareAuthUser, z as FlareAuthHydrationInput, G as FlareAuthHydrationOptions, i as BrowserPushTokenOptions, B as BrowserPushRegistrationOptions, a4 as RegisterPushTokenInput, a9 as SendPushNotificationInput, Y as PushSendResult, e as AuthResult } from './index-BAvE1URE.js';
+import { aX as WhereCondition, aP as SubscriptionCallback, as as QueryConfig, E as DocUpdatedCallback, z as DocDeletedCallback, y as DocChangedCallback, au as QueryPresetMap, av as QueryPresetParams, aw as QueryPresetRow, a as AggregateSpec, aa as HavingClause, ad as JoinClause, aV as VectorSearchClause, aN as StructuredQuery, aT as SubscriptionHandle, q as CollectionStreamOptions, n as CollectionStream, m as CollectionExternalStore, x as DocAddedCallback, F as FlareConfig, aO as SubscribeOptions, aS as SubscriptionErrorCallback, aR as SubscriptionError, r as ConnectionState, al as PresenceCallback, am as PresenceJoinCallback, an as PresenceLeaveCallback, aU as VectorFieldConfig, ax as QueryPresetSpec, a4 as FlareStorageTransferManagerConfig, aJ as StorageProgress, aH as StorageBucketInput, aG as StorageBucket, k as BucketPolicyInput, Z as FlareStorageRulesPolicy, j as BucketCorsRule, Y as FlareStorageRulesHistoryResult, aq as PutObjectInput, ar as PutObjectResult, a6 as GetObjectInput, a7 as GetObjectResult, a8 as GetObjectUrlInput, H as DownloadObjectInput, I as DownloadObjectResult, ab as HeadObjectInput, aI as StorageObjectMeta, ac as HeadObjectsInput, af as ListObjectsInput, ag as ListObjectsResult, s as CopyObjectInput, v as DeleteObjectInput, w as DeleteObjectsInput, aK as StorageSignedUrlInput, a3 as FlareStorageSignedUrlResult, L as FlareAuthConfig, f as AuthStateListener, d as AuthConfigListener, Q as FlareAuthSession, R as FlareAuthUser, M as FlareAuthHydrationInput, N as FlareAuthHydrationOptions, i as BrowserPushTokenOptions, B as BrowserPushRegistrationOptions, az as RegisterPushTokenInput, aE as SendPushNotificationInput, ap as PushSendResult, e as AuthResult } from './index-Y0Mq_6P9.cjs';
 import { AuthToken } from '@zuzjs/auth';
 
 /**
@@ -508,6 +508,168 @@ declare class FlareBase<TPresetMap extends QueryPresetMap = {}> {
     protected handleIncoming(msg: any): void;
 }
 
+interface FlareStorageTransport {
+    readonly appId: string;
+    readonly transferManager?: FlareStorageTransferManagerConfig;
+    call(topic: string, payload?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    subscribe(subId: string, collection: string, docId: string | undefined, query: unknown, callback: (event: any) => void, options?: {
+        skipSnapshot?: boolean;
+    }): () => void;
+    doPost(label: string, path: string, body: unknown): Promise<Record<string, unknown>>;
+    doGet(label: string, path: string): Promise<Record<string, unknown>>;
+    doPostWithProgress(label: string, path: string, body: unknown, onProgress: (p: StorageProgress) => void): Promise<Record<string, unknown>>;
+}
+/**
+ * S3-compatible storage service returned by `app.storage()`.
+ *
+ * Works with bucket **names** (not internal server IDs). Server IDs are
+ * resolved lazily and cached. `putObject()` automatically creates the bucket
+ * if it does not yet exist.
+ */
+declare class FlareStorage {
+    private readonly _t;
+    private readonly _transferEnabled;
+    private readonly _uploadLimiter;
+    private readonly _downloadLimiter;
+    /** bucket-name → serverId cache */
+    private readonly _bucketCache;
+    private _bucketListLoaded;
+    private _bucketListPromise;
+    constructor(transport: FlareStorageTransport);
+    private _scheduleUpload;
+    private _scheduleDownload;
+    private _ensureBuckets;
+    private _loadBuckets;
+    private _invalidateBucketCache;
+    /**
+     * Resolves a bucket name to its internal serverId.
+     * When `autoCreate` is true, creates the bucket if it does not exist.
+     */
+    private _resolveBucketId;
+    private _appPath;
+    private _bucketStreamCollection;
+    private _objectStreamCollection;
+    private _subscribeStorage;
+    /**
+     * Creates a new bucket (storage server) for the app.
+     *
+     * Idempotent: if a bucket with this name already exists the existing one
+     * is returned unchanged (same behaviour as AWS S3 for same-owner buckets).
+     */
+    createBucket(name: string, options?: StorageBucketInput): Promise<StorageBucket>;
+    private _listBucketsRaw;
+    /** Returns all buckets for the app. */
+    listBuckets(): Promise<StorageBucket[]>;
+    /** Deletes a bucket and all its objects. */
+    deleteBucket(name: string): Promise<{
+        ok: boolean;
+        removedObjects: number;
+    }>;
+    /** Deletes multiple buckets. */
+    deleteBuckets(names: string[]): Promise<{
+        ok: boolean;
+        deleted: string[];
+        errors: Record<string, string>;
+    }>;
+    /** Returns location info for a bucket (kind, region, endpoint). */
+    getBucketLocation(name: string): Promise<{
+        bucket: string;
+        kind: string;
+        region?: string;
+        endpoint?: string;
+    }>;
+    onBucketAdded(callback: (bucket: StorageBucket, bucketId: string) => void): () => void;
+    onBucketUpdated(callback: (bucket: StorageBucket, bucketId: string) => void): () => void;
+    onBucketDeleted(callback: (bucketId: string) => void): () => void;
+    /**
+     * Sets security rules for storage.
+     * Rules apply app-wide (all buckets share the same rules DSL).
+     */
+    putBucketPolicy(input: BucketPolicyInput): Promise<{
+        id: string;
+    }>;
+    /** Gets the current storage rules policy. */
+    getBucketPolicy(): Promise<{
+        rulesDsl?: string;
+        rules?: unknown;
+        policy: FlareStorageRulesPolicy;
+    }>;
+    /**
+     * Sets CORS rules for a bucket.
+     * Note: CORS is configured at the flare-node server level; this method
+     * stores the rules in app settings for reference.
+     */
+    putBucketCors(_bucket: string, _rules: BucketCorsRule[]): Promise<{
+        ok: boolean;
+    }>;
+    /** Alias for putBucketCors. */
+    setBucketCors: (_bucket: string, _rules: BucketCorsRule[]) => Promise<{
+        ok: boolean;
+    }>;
+    /** Returns the full storage rules/policy history. */
+    rulesHistory(): Promise<FlareStorageRulesHistoryResult>;
+    /**
+     * Uploads an object to a bucket.
+     *
+     * The bucket is created automatically if it does not exist.
+     * Default path is direct raw upload via signed URL (no base64 encoding).
+     * Set `base64: true` to prefer legacy base64 upload for small payloads.
+     * Provide `onProgress` for upload progress updates (browser only).
+     */
+    putObject(input: PutObjectInput): Promise<PutObjectResult>;
+    /**
+     * Downloads an object from a bucket.
+     * Returns base64-encoded content.
+     */
+    getObject(input: GetObjectInput): Promise<GetObjectResult>;
+    /** Returns a short-lived signed URL for direct browser/object download. */
+    getObjectUrl(input: GetObjectUrlInput): Promise<string>;
+    /**
+     * Triggers browser download using a signed URL and returns the resolved URL.
+     * In non-browser runtimes, this only returns the URL without dispatching a click.
+     */
+    downloadObject(input: DownloadObjectInput): Promise<DownloadObjectResult>;
+    /** Returns object metadata without downloading the content. */
+    headObject(input: HeadObjectInput): Promise<StorageObjectMeta>;
+    /** Returns metadata for multiple objects in parallel. */
+    headObjects(input: HeadObjectsInput): Promise<StorageObjectMeta[]>;
+    /**
+     * Lists objects in a bucket with optional prefix filter and pagination.
+     *
+     * Pass the returned `cursor` to the next call to page through results.
+     */
+    listObjects(input: ListObjectsInput): Promise<ListObjectsResult>;
+    /**
+     * Copies an object from one bucket/key to another.
+     * Source and destination can be different buckets in the same app.
+     */
+    copyObject(input: CopyObjectInput): Promise<{
+        ok: boolean;
+    }>;
+    /** Copies multiple objects. Runs concurrently. */
+    copyObjects(inputs: CopyObjectInput[]): Promise<{
+        ok: boolean;
+        errors: Record<string, string>;
+    }>;
+    /** Deletes a single object. */
+    deleteObject(input: DeleteObjectInput): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Deletes multiple objects in a single server request.
+     */
+    deleteObjects(input: DeleteObjectsInput): Promise<{
+        ok: boolean;
+        deleted: string[];
+        errors: Record<string, string>;
+    }>;
+    onObjectAdded(bucket: string, callback: (object: StorageObjectMeta, key: string) => void): () => void;
+    onObjectUpdated(bucket: string, callback: (object: StorageObjectMeta, key: string) => void): () => void;
+    onObjectDeleted(bucket: string, callback: (key: string) => void): () => void;
+    /** Issues a short-lived signed URL for direct client-to-flare uploads or downloads. */
+    createSignedUrl(input: StorageSignedUrlInput): Promise<FlareStorageSignedUrlResult>;
+}
+
 declare class FlareAuth<TPresetMap extends QueryPresetMap = {}> extends FlareBase<TPresetMap> {
     static AUTH_TRACE_STORAGE_KEY: string;
     protected pushServiceWorkerInitPromise?: Promise<ServiceWorkerRegistration | null>;
@@ -527,6 +689,8 @@ declare class FlareAuth<TPresetMap extends QueryPresetMap = {}> extends FlareBas
     protected csrfToken?: string;
     protected csrfBootstrapAttempted: boolean;
     protected csrfInitPromise?: Promise<void>;
+    /** Lazy singleton FlareStorage service. */
+    private _storageService;
     protected isAuthTraceEnabled(): boolean;
     protected traceAuth(event: string, details?: Record<string, unknown>): void;
     setAuthTrace(enabled: boolean, persist?: boolean): void;
@@ -615,6 +779,76 @@ declare class FlareAuth<TPresetMap extends QueryPresetMap = {}> extends FlareBas
         removed: boolean;
     }>;
     sendPushNotification(input: SendPushNotificationInput): Promise<PushSendResult>;
+    /**
+     * Returns the S3-compatible storage service for this app.
+     *
+     * Works with bucket **names** — no serverId needed.
+     * Buckets are created automatically on `putObject()` if they don't exist yet.
+     *
+     * @example
+     * const s = app.storage();
+     * await s.putObject({ bucket: 'avatars', key: 'alice.png', body: file });
+     * const { contentBase64 } = await s.getObject({ bucket: 'avatars', key: 'alice.png' });
+     */
+    storage(): FlareStorage;
+    private _buildStorageTransport;
+    /** @see FlareStorage.putObject */
+    putObject(input: PutObjectInput): Promise<PutObjectResult>;
+    /** @see FlareStorage.getObject */
+    getObject(input: GetObjectInput): Promise<GetObjectResult>;
+    /** @see FlareStorage.getObjectUrl */
+    getObjectUrl(input: GetObjectUrlInput): Promise<string>;
+    /** @see FlareStorage.downloadObject */
+    downloadObject(input: DownloadObjectInput): Promise<DownloadObjectResult>;
+    /** @see FlareStorage.headObject */
+    headObject(input: HeadObjectInput): Promise<StorageObjectMeta>;
+    /** @see FlareStorage.headObjects */
+    headObjects(input: HeadObjectsInput): Promise<StorageObjectMeta[]>;
+    /** @see FlareStorage.listObjects */
+    listObjects(input: ListObjectsInput): Promise<ListObjectsResult>;
+    /** @see FlareStorage.copyObject */
+    copyObject(input: CopyObjectInput): Promise<{
+        ok: boolean;
+    }>;
+    /** @see FlareStorage.copyObjects */
+    copyObjects(inputs: CopyObjectInput[]): Promise<{
+        ok: boolean;
+        errors: Record<string, string>;
+    }>;
+    /** @see FlareStorage.deleteObject */
+    deleteObject(input: DeleteObjectInput): Promise<{
+        ok: boolean;
+    }>;
+    /** @see FlareStorage.deleteObjects */
+    deleteObjects(input: DeleteObjectsInput): Promise<{
+        ok: boolean;
+        deleted: string[];
+        errors: Record<string, string>;
+    }>;
+    /** @see FlareStorage.createBucket */
+    createBucket(name: string, options?: StorageBucketInput): Promise<StorageBucket>;
+    /** @see FlareStorage.listBuckets */
+    listBuckets(): Promise<StorageBucket[]>;
+    /** @see FlareStorage.deleteBucket */
+    deleteBucket(name: string): Promise<{
+        ok: boolean;
+        removedObjects: number;
+    }>;
+    /** @see FlareStorage.deleteBuckets */
+    deleteBuckets(names: string[]): Promise<{
+        ok: boolean;
+        deleted: string[];
+        errors: Record<string, string>;
+    }>;
+    /** @see FlareStorage.getBucketLocation */
+    getBucketLocation(name: string): Promise<{
+        bucket: string;
+        kind: string;
+        region?: string;
+        endpoint?: string;
+    }>;
+    /** @see FlareStorage.createSignedUrl */
+    createSignedUrl(input: StorageSignedUrlInput): Promise<FlareStorageSignedUrlResult>;
     auth(token: string): Promise<AuthResult>;
     private getAuthRequestContentType;
     private buildAuthRequestBody;
@@ -826,4 +1060,4 @@ declare class FlareClient<TPresetMap extends QueryPresetMap = {}> extends FlareA
     autoEnablePushNotifications(): Promise<void>;
 }
 
-export { type BaseMessage as B, type CollectionPresetMethods as C, DocumentQueryBuilder as D, FlareClient as F, type SubscribeMessage as S, type CollectionQuery as a, CollectionReference as b, DocumentReference as c, FlareAction as d, FlareEvent as e, parseWhereCondition as f, parseValue as p };
+export { type BaseMessage as B, type CollectionPresetMethods as C, DocumentQueryBuilder as D, FlareClient as F, type SubscribeMessage as S, type CollectionQuery as a, CollectionReference as b, DocumentReference as c, FlareAction as d, FlareEvent as e, FlareStorage as f, parseWhereCondition as g, parseValue as p };