firstly 0.5.1 → 0.6.0

package/esm/svelte/FF_Repo.svelte.js

@@ -1,305 +0,0 @@
-import { repo as remultRepo, } from 'remult';
-/**
- * The reactive handle implementation. Not exported directly - consumers use a per-mode
- * alias (`FF_RepoLoad`/`FF_RepoLive`/`FF_RepoPaginate`/`FF_RepoOne`) or the umbrella
- * union `FF_Repo` (any mode). Each verb returns the Omit'd per-mode view of this.
- */
-class FF_RepoHandle {
-    #repo;
-    #opts;
-    #mode;
-    #defaultOrderBy;
-    #paginator;
-    #seq = 0;
-    items = $state([]);
-    /** Single-record slot: the loaded row in `one` mode, or a create/edit draft (see `create`). */
-    item = $state(undefined);
-    loading = $state({
-        init: true,
-        fetching: false,
-        more: false,
-        saving: false,
-        deleting: false,
-    });
-    error = $state(undefined);
-    hasNextPage = $state(false);
-    /** Aggregations for the whole query (paginate mode). `aggregates.$count` is the total row count. */
-    aggregates = $state(undefined);
-    constructor(r, opts, mode) {
-        this.#repo = r;
-        this.#opts = opts;
-        this.#mode = mode;
-        this.#defaultOrderBy = r.metadata.options.defaultOrderBy;
-        $effect(() => {
-            const o = this.#resolve();
-            if (o.enabled === false) {
-                this.loading.init = false;
-                return;
-            }
-            if (mode === 'live') {
-                // Pass orderBy so liveQuery re-sorts incrementally-added rows too;
-                // without it a freshly inserted row is appended and `items[0]` (the latest) goes stale.
-                const unsub = this.#repo
-                    .liveQuery({ where: o.where, orderBy: o.orderBy, limit: o.limit, include: o.include })
-                    .subscribe({
-                    next: (info) => {
-                        this.items = info.items;
-                        this.loading.init = false;
-                    },
-                    error: (e) => {
-                        this.error = e instanceof Error ? e.message : String(e);
-                        this.loading.init = false;
-                    },
-                });
-                return () => unsub();
-            }
-            // load | paginate | one: (re)fetch; a newer opts() invalidates older responses.
-            void this.#load(o, ++this.#seq);
-        });
-    }
-    #resolve() {
-        const o = this.#opts();
-        return { ...o, orderBy: o.orderBy ?? this.#defaultOrderBy };
-    }
-    async #load(o, seq, keepCount) {
-        this.loading.fetching = true;
-        this.error = undefined;
-        try {
-            if (this.#mode === 'paginate') {
-                // One request returns the page AND the aggregates ($count always, plus any
-                // requested): on the client REST proxy remult fetches both together. It sets
-                // `hasNextPage` from whether a full page came back (no count probe); `more()`
-                // then fetches the next page via a keyset cursor (orderBy + PK).
-                const p = await this.#repo
-                    .query({
-                    where: o.where,
-                    orderBy: o.orderBy,
-                    pageSize: keepCount ?? o.pageSize ?? 25,
-                    include: o.include,
-                    aggregate: { ...o.aggregate },
-                })
-                    .paginator();
-                if (seq !== this.#seq)
-                    return;
-                this.#paginator = p;
-                this.items = p.items;
-                this.hasNextPage = p.hasNextPage;
-                // `aggregates` is only on the paginator type when the aggregate is non-empty,
-                // but remult returns `$count` for the empty case too - so read it through a cast.
-                this.aggregates = p.aggregates;
-            }
-            else if (this.#mode === 'one') {
-                const found = await this.#repo.findFirst(o.where, {
-                    orderBy: o.orderBy,
-                    include: o.include,
-                });
-                if (seq !== this.#seq)
-                    return;
-                this.item = found ?? undefined;
-                this.items = found ? [found] : [];
-            }
-            else {
-                const items = await this.#repo.find({
-                    where: o.where,
-                    orderBy: o.orderBy,
-                    limit: o.limit,
-                    include: o.include,
-                });
-                if (seq !== this.#seq)
-                    return;
-                this.items = items;
-            }
-        }
-        catch (e) {
-            if (seq === this.#seq)
-                this.error = e instanceof Error ? e.message : String(e);
-        }
-        finally {
-            if (seq === this.#seq) {
-                this.loading.init = false;
-                this.loading.fetching = false;
-            }
-        }
-    }
-    /** Re-run the current query (load/paginate/one), back to the first page. */
-    async refresh() {
-        if (this.#mode === 'live')
-            throw new Error('FF_Repo: refresh() is not available in live mode');
-        await this.#load(this.#resolve(), ++this.#seq);
-    }
-    /** Load and append the next page (paginate mode). */
-    async more() {
-        if (this.#mode !== 'paginate')
-            throw new Error('FF_Repo: more() requires paginate mode');
-        if (!this.#paginator || this.loading.more || !this.hasNextPage)
-            return;
-        this.loading.more = true;
-        try {
-            const next = await this.#paginator.nextPage();
-            this.#paginator = next;
-            this.items = [...this.items, ...next.items];
-            this.hasNextPage = next.hasNextPage;
-        }
-        finally {
-            this.loading.more = false;
-        }
-    }
-    /**
-     * Run `fn` once - the first time a row exists (`items[0]`).
-     *
-     * The point: seed editable UI state from the latest row WITHOUT a live query
-     * clobbering in-progress edits. It fires a single time, on the first non-empty
-     * result, and never again - later ticks (an edit, a delete, a re-sort) are
-     * ignored. Empty snapshots are skipped (a liveQuery often emits one before the
-     * data lands; there is nothing to seed from an empty result).
-     *
-     * For pure derived state prefer `$derived`; reach for `onFirst` only when the
-     * seed must become independently editable (a draft the user then mutates).
-     *
-     * ```svelte
-     * const list = ffRepo(Plan).listen(() => ({ where: { ownerDid } }))
-     * let draft = $state({ title: '' })
-     * list.onFirst((latest) => (draft.title = latest.title)) // seed once, then edit freely
-     * ```
-     */
-    onFirst(fn) {
-        let done = false;
-        $effect(() => {
-            if (done)
-                return;
-            const latest = this.items[0];
-            if (latest == null)
-                return;
-            fn(latest);
-            done = true;
-        });
-    }
-    /** Create a new unsaved entity into the `item` slot (for an edit form). */
-    create(...args) {
-        this.item = this.#repo.create(...args);
-        return this.item;
-    }
-    // Mutations: run `op`, then the post-write sync on SUCCESS only (a failed write
-    // leaves the result untouched). On failure we fill `error` AND re-throw - the
-    // caller still gets the rejection (not silenced); `error` is for a reactive
-    // UI that wants it. `finally` only flips `loading` (no `await`, which would
-    // mask the original error).
-    async #write(flag, op, after) {
-        this.loading[flag] = true;
-        this.error = undefined;
-        try {
-            const res = await op();
-            await after();
-            return res;
-        }
-        catch (e) {
-            this.error = e instanceof Error ? e.message : String(e);
-            throw e;
-        }
-        finally {
-            this.loading[flag] = false;
-        }
-    }
-    /** Save the current `item` (from `one` / `create()`). To save a specific row, use `.repo.save(row)`. */
-    save() {
-        return this.#write('saving', () => this.#repo.save(this.#requireItem()), () => this.#resync());
-    }
-    /** Delete the current `item`. To delete a specific row/id, use `.repo.delete(idOrRow)`. */
-    delete() {
-        const target = this.#requireItem();
-        return this.#write('deleting', () => this.#repo.delete(target), () => {
-            // live: liveQuery removes it. one: re-fetch (likely empty now).
-            // load/paginate: drop it locally (no refetch).
-            if (this.#mode === 'live')
-                return;
-            if (this.#mode === 'one')
-                return this.#resync();
-            this.#removeLocal(target);
-        });
-    }
-    /** The current `item` (or throw) - backs the argless `save()`/`delete()`. */
-    #requireItem() {
-        if (this.item === undefined)
-            throw new Error('FF_Repo: no `item` to save/delete - load one first (`one` mode or `create()`), or write a specific row through `.repo`.');
-        return this.item;
-    }
-    // Client-side list reconcilers (no server I/O) - reflect a change you made
-    // elsewhere (e.g. via `.repo`) in the reactive `items`. `load`/`paginate` only;
-    // `listen` reconciles itself via the liveQuery. `add`/`remove` also adjust
-    // `aggregates.$count` (not the other aggregates). For authoritative state, call
-    // `refresh()` (it re-pulls and, for paginate, resets to the first page).
-    /** Insert into `items` at `top` (default) / `bottom` / an index (`-1` = last). +1 to `$count`. */
-    addItem(item, options) {
-        const at = options?.at ?? 'top';
-        const list = this.items;
-        const idx = at === 'top'
-            ? 0
-            : at === 'bottom'
-                ? list.length
-                : at < 0
-                    ? Math.max(0, list.length + at + 1)
-                    : Math.min(at, list.length);
-        this.items = [...list.slice(0, idx), item, ...list.slice(idx)];
-        if (this.aggregates)
-            this.aggregates.$count += 1;
-    }
-    /** Replace the row whose id matches `item`'s id (no `$count` change). */
-    updateItem(item) {
-        const id = this.#repo.metadata.idMetadata.getId(item);
-        this.items = this.items.map((x) => (this.#repo.metadata.idMetadata.getId(x) === id ? item : x));
-    }
-    /** Drop the matching row (pass an id or the item). -1 to `$count`. */
-    removeItem(idOrItem) {
-        this.#removeLocal(idOrItem);
-    }
-    #removeLocal(idOrItem) {
-        const id = idOrItem != null && typeof idOrItem === 'object'
-            ? this.#repo.metadata.idMetadata.getId(idOrItem)
-            : idOrItem;
-        this.items = this.items.filter((i) => this.#repo.metadata.idMetadata.getId(i) !== id);
-        if (this.aggregates)
-            this.aggregates.$count = Math.max(0, this.aggregates.$count - 1);
-    }
-    /** After insert/update (or a `one` delete) in a non-live mode, re-fetch keeping the current count. */
-    async #resync() {
-        if (this.#mode === 'live')
-            return;
-        const keepCount = this.#mode === 'paginate' ? this.items.length || undefined : undefined;
-        await this.#load(this.#resolve(), ++this.#seq, keepCount);
-    }
-    /**
-     * The entity's remult metadata - the single escape hatch for everything not on
-     * this handle: permissions (`apiInsertAllowed()`, `apiUpdateAllowed(item)`,
-     * `apiDeleteAllowed(item)`, `apiReadAllowed`), `fields`, `idMetadata`, `options`,
-     * `key`. Reflects the current `remult.user`.
-     */
-    get meta() {
-        return this.#repo.metadata;
-    }
-    /** Escape hatch to the underlying repo (count, findId, upsert, projections, ...). */
-    get repo() {
-        return this.#repo;
-    }
-}
-export function ffRepo(entity) {
-    const r = remultRepo(entity);
-    const builder = {
-        load(o) {
-            return new FF_RepoHandle(r, o, 'load');
-        },
-        listen(o) {
-            return new FF_RepoHandle(r, o, 'live');
-        },
-        paginate(o) {
-            return new FF_RepoHandle(r, o, 'paginate');
-        },
-        one(o) {
-            return new FF_RepoHandle(r, o, 'one');
-        },
-        get meta() {
-            return r.metadata;
-        },
-        repo: r,
-    };
-    return builder;
-}