@go-avro/avro-js 0.0.29 → 0.0.31

package/dist/client/QueryClient.d.ts

@@ -537,6 +537,14 @@ export declare class AvroQueryClient {
      * Called once from AvroQueryClientProvider when the tanstack
      * QueryClient is available.  Also handles auto-joining the
      * company room on connect so consumer apps don't have to.
+     *
+     * Targeted events (single-entity CRUD) receive `{ id }` from the
+     * backend and surgically create / update / remove only the
+     * affected cache entries.  Bulk events fall back to full
+     * query-key invalidation.
+     *
+     * Backward-compatible: if a targeted event arrives without an id
+     * (old backend), we fall back to full invalidation.
      */
     setupSocketInvalidation(queryClient: QueryClient): void;
     /**

package/dist/client/QueryClient.js

@@ -4,83 +4,98 @@ import { v4 as uuidv4 } from "uuid";
 import { LoginResponse } from '../types/api';
 import { AuthState } from '../types/auth';
 import { StandardError } from '../types/error';
+function isBulkEvent(c) {
+    return 'invalidateKeys' in c;
+}
 /**
- * Maps socket event names to the query keys that should be invalidated
- * when that event is received. Chat events are excluded — they carry
- * their own data and are handled separately by consumer apps.
+ * Maps socket event names to cache-update strategies.
+ *
+ * *Targeted* events receive `{ id }` from the backend and surgically
+ * update / insert / remove only the affected cache entries.
+ *
+ * *Bulk* events (plural mutations, scheduling, etc.) fall back to
+ * full query-key invalidation because the backend doesn't emit per-item ids.
  */
-const SOCKET_INVALIDATION_MAP = {
-    // Company
-    create_company: [['companies']],
-    update_company: [['companies']],
-    delete_company: [['companies']],
-    // Users
-    user_updated: [['users']],
-    update_users: [['users']],
-    // Jobs
-    create_job: [['jobs']],
-    update_job: [['jobs']],
-    update_jobs: [['jobs']],
-    delete_job: [['jobs']],
-    delete_jobs: [['jobs']],
-    // Routes
-    create_route: [['routes']],
-    update_route: [['routes']],
-    delete_route: [['routes']],
-    // Events
-    create_event: [['events']],
-    update_event: [['events']],
-    update_events: [['events']],
-    delete_event: [['events']],
-    // Teams
-    create_team: [['teams']],
-    update_team: [['teams']],
-    update_teams: [['teams']],
-    delete_team: [['teams']],
-    // Bills
-    create_bill: [['bills']],
-    update_bills: [['bills']],
-    delete_bill: [['bills']],
-    // Sessions
-    create_session: [['sessions']],
-    update_session: [['sessions']],
-    // Catalog
-    create_catalog_item: [['catalog_items']],
-    update_catalog_item: [['catalog_items']],
-    delete_catalog_item: [['catalog_items']],
-    // Groups
-    create_group: [['groups']],
-    update_group: [['groups']],
-    delete_group: [['groups']],
-    // Labels
-    create_label: [['labels']],
-    update_label: [['labels']],
-    delete_label: [['labels']],
-    // Skills
-    create_skill: [['skills']],
-    update_skill: [['skills']],
-    delete_skill: [['skills']],
-    // Proposals
-    create_proposal: [['proposals']],
-    update_proposal: [['proposals']],
-    delete_proposal: [['proposals']],
-    // Service Months
-    create_month: [['months']],
-    update_months: [['months']],
-    delete_months: [['months']],
-    // Tasks
-    create_task: [['jobs']],
-    update_task: [['jobs']],
-    delete_task: [['jobs']],
-    // Scheduling
-    schedule_complete: [['routes'], ['jobs']],
-    // Location
-    location_update: [['teams']],
-    // Prepayments
-    update_prepayments: [['prepayments']],
-    // Chats
-    new_message: [['chats'], ['messages']],
+const SOCKET_EVENT_CONFIG = {
+    // ── Company ──
+    create_company: { entityKey: 'companies', action: 'create', fetchPath: (id) => `/company/${id}` },
+    update_company: { entityKey: 'companies', action: 'update', fetchPath: (id) => `/company/${id}` },
+    delete_company: { entityKey: 'companies', action: 'delete', fetchPath: null },
+    // ── Users (no single-entity socket events) ──
+    user_updated: { invalidateKeys: [['users'], ['user']] },
+    update_users: { invalidateKeys: [['users'], ['user']] },
+    // ── Jobs ──
+    create_job: { entityKey: 'jobs', action: 'create', fetchPath: (id) => `/job/${id}` },
+    update_job: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}` },
+    delete_job: { entityKey: 'jobs', action: 'delete', fetchPath: null },
+    update_jobs: { invalidateKeys: [['jobs'], ['infinite', 'jobs']] },
+    delete_jobs: { invalidateKeys: [['jobs'], ['infinite', 'jobs']] },
+    // ── Routes ──
+    create_route: { entityKey: 'routes', action: 'create', fetchPath: (id) => `/route/${id}` },
+    update_route: { entityKey: 'routes', action: 'update', fetchPath: (id) => `/route/${id}` },
+    delete_route: { entityKey: 'routes', action: 'delete', fetchPath: null },
+    // ── Events ──
+    create_event: { entityKey: 'events', action: 'create', fetchPath: (id) => `/event/${id}` },
+    update_event: { entityKey: 'events', action: 'update', fetchPath: (id) => `/event/${id}` },
+    delete_event: { entityKey: 'events', action: 'delete', fetchPath: null },
+    update_events: { invalidateKeys: [['events']] },
+    // ── Teams ──
+    create_team: { entityKey: 'teams', action: 'create', fetchPath: null },
+    update_team: { entityKey: 'teams', action: 'update', fetchPath: null },
+    delete_team: { entityKey: 'teams', action: 'delete', fetchPath: null },
+    update_teams: { invalidateKeys: [['teams']] },
+    // ── Bills ──
+    create_bill: { entityKey: 'bills', action: 'create', fetchPath: (id) => `/bill/${id}` },
+    delete_bill: { entityKey: 'bills', action: 'delete', fetchPath: null },
+    update_bills: { invalidateKeys: [['bills']] },
+    // ── Sessions ──
+    create_session: { entityKey: 'sessions', action: 'create', fetchPath: null },
+    update_session: { entityKey: 'sessions', action: 'update', fetchPath: null },
+    // ── Catalog Items ──
+    create_catalog_item: { entityKey: 'catalog_items', action: 'create', fetchPath: (id) => `/catalog_item/${id}` },
+    update_catalog_item: { entityKey: 'catalog_items', action: 'update', fetchPath: (id) => `/catalog_item/${id}` },
+    delete_catalog_item: { entityKey: 'catalog_items', action: 'delete', fetchPath: null },
+    // ── Groups ──
+    create_group: { entityKey: 'groups', action: 'create', fetchPath: null },
+    update_group: { entityKey: 'groups', action: 'update', fetchPath: null },
+    delete_group: { entityKey: 'groups', action: 'delete', fetchPath: null },
+    // ── Labels ──
+    create_label: { entityKey: 'labels', action: 'create', fetchPath: null },
+    update_label: { entityKey: 'labels', action: 'update', fetchPath: null },
+    delete_label: { entityKey: 'labels', action: 'delete', fetchPath: null },
+    // ── Skills ──
+    create_skill: { entityKey: 'skills', action: 'create', fetchPath: null },
+    update_skill: { entityKey: 'skills', action: 'update', fetchPath: null },
+    delete_skill: { entityKey: 'skills', action: 'delete', fetchPath: null },
+    // ── Proposals ──
+    create_proposal: { entityKey: 'proposals', action: 'create', fetchPath: (id) => `/proposal/${id}` },
+    update_proposal: { entityKey: 'proposals', action: 'update', fetchPath: (id) => `/proposal/${id}` },
+    delete_proposal: { entityKey: 'proposals', action: 'delete', fetchPath: null },
+    // ── Service Months ──
+    create_month: { entityKey: 'months', action: 'create', fetchPath: null },
+    update_months: { invalidateKeys: [['months']] },
+    delete_months: { invalidateKeys: [['months']] },
+    // ── Tasks (nested under jobs — target the parent job) ──
+    create_task: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, idField: 'job_id' },
+    update_task: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, idField: 'job_id' },
+    delete_task: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, idField: 'job_id' },
+    // ── Scheduling ──
+    schedule_complete: { invalidateKeys: [['routes'], ['jobs'], ['infinite', 'jobs']] },
+    // ── Location ──
+    location_update: { invalidateKeys: [['teams']] },
+    // ── Prepayments ──
+    update_prepayments: { invalidateKeys: [['prepayments']] },
+    // ── Chats ──
+    new_message: { invalidateKeys: [['chats'], ['messages']] },
 };
+/**
+ * Returns true when `query.queryKey` belongs to the given entity,
+ * including the `['infinite', entityKey, ...]` variant used by jobs.
+ */
+function matchesEntityKey(query, entityKey) {
+    const k = query.queryKey;
+    return k[0] === entityKey || (k[0] === 'infinite' && k[1] === entityKey);
+}
 export class AvroQueryClient {
     constructor(config) {
         this._authState = AuthState.UNKNOWN;
@@ -157,6 +172,14 @@ export class AvroQueryClient {
      * Called once from AvroQueryClientProvider when the tanstack
      * QueryClient is available.  Also handles auto-joining the
      * company room on connect so consumer apps don't have to.
+     *
+     * Targeted events (single-entity CRUD) receive `{ id }` from the
+     * backend and surgically create / update / remove only the
+     * affected cache entries.  Bulk events fall back to full
+     * query-key invalidation.
+     *
+     * Backward-compatible: if a targeted event arrives without an id
+     * (old backend), we fall back to full invalidation.
      */
     setupSocketInvalidation(queryClient) {
         // Prevent double-setup
@@ -164,15 +187,142 @@ export class AvroQueryClient {
             return;
         this._queryClient = queryClient;
         const handlers = [];
-        // Register invalidation listeners for every mapped event
-        for (const [event, queryKeys] of Object.entries(SOCKET_INVALIDATION_MAP)) {
-            const handler = () => {
-                for (const key of queryKeys) {
-                    queryClient.invalidateQueries({ queryKey: key });
-                }
-            };
-            this.socket.on(event, handler);
-            handlers.push({ event, handler });
+        const client = this; // stable reference for async closures
+        /** Full-invalidate every key that matches the entity (including 'infinite' prefix). */
+        const invalidateEntity = (entityKey) => {
+            queryClient.invalidateQueries({ predicate: (q) => matchesEntityKey(q, entityKey) });
+        };
+        for (const [event, config] of Object.entries(SOCKET_EVENT_CONFIG)) {
+            if (isBulkEvent(config)) {
+                // ── Bulk: invalidate all specified keys ──────────────
+                const handler = () => {
+                    for (const key of config.invalidateKeys) {
+                        queryClient.invalidateQueries({ queryKey: key });
+                    }
+                };
+                this.socket.on(event, handler);
+                handlers.push({ event, handler });
+            }
+            else {
+                // ── Targeted: surgical cache update ──────────────────
+                const { entityKey, action, fetchPath, idField, alsoInvalidate } = config;
+                const handler = async (data) => {
+                    const id = data?.[idField ?? 'id'];
+                    // No id → old backend or malformed payload → full invalidation
+                    if (!id || typeof id !== 'string') {
+                        invalidateEntity(entityKey);
+                        alsoInvalidate?.forEach((k) => queryClient.invalidateQueries({ queryKey: k }));
+                        return;
+                    }
+                    const entityPredicate = (q) => matchesEntityKey(q, entityKey);
+                    switch (action) {
+                        // ─── CREATE ─────────────────────────────────
+                        case 'create': {
+                            if (fetchPath) {
+                                try {
+                                    const item = await queryClient.fetchQuery({
+                                        queryKey: [entityKey, id],
+                                        queryFn: () => client.get({ path: fetchPath(id) }),
+                                        staleTime: 0,
+                                    });
+                                    queryClient.setQueriesData({ predicate: entityPredicate, type: 'active' }, (old) => {
+                                        if (!old)
+                                            return old;
+                                        if (old.pages && Array.isArray(old.pages)) {
+                                            // Skip if already present (avoids duplicates
+                                            // when the creating user also gets the event)
+                                            if (old.pages.some((p) => p.some((x) => x?.id === id)))
+                                                return old;
+                                            return {
+                                                ...old,
+                                                pages: [
+                                                    [item, ...(old.pages[0] || [])],
+                                                    ...old.pages.slice(1),
+                                                ],
+                                            };
+                                        }
+                                        if (Array.isArray(old)) {
+                                            if (old.some((x) => x?.id === id))
+                                                return old;
+                                            return [...old, item];
+                                        }
+                                        return old;
+                                    });
+                                }
+                                catch {
+                                    invalidateEntity(entityKey);
+                                }
+                            }
+                            else {
+                                // No individual GET endpoint → invalidate lists
+                                invalidateEntity(entityKey);
+                            }
+                            break;
+                        }
+                        // ─── UPDATE ─────────────────────────────────
+                        case 'update': {
+                            if (fetchPath) {
+                                try {
+                                    // Fetch fresh copy (also updates the [entity, id] cache)
+                                    const item = await queryClient.fetchQuery({
+                                        queryKey: [entityKey, id],
+                                        queryFn: () => client.get({ path: fetchPath(id) }),
+                                        staleTime: 0,
+                                    });
+                                    // Patch it into every active list / infinite-query cache
+                                    queryClient.setQueriesData({ predicate: entityPredicate, type: 'active' }, (old) => {
+                                        if (!old)
+                                            return old;
+                                        if (old.pages && Array.isArray(old.pages)) {
+                                            return {
+                                                ...old,
+                                                pages: old.pages.map((page) => page.map((x) => (x?.id === id ? item : x))),
+                                            };
+                                        }
+                                        if (Array.isArray(old)) {
+                                            return old.map((x) => (x?.id === id ? item : x));
+                                        }
+                                        return old;
+                                    });
+                                }
+                                catch {
+                                    invalidateEntity(entityKey);
+                                }
+                            }
+                            else {
+                                // No individual GET → invalidate everything for this entity
+                                invalidateEntity(entityKey);
+                            }
+                            break;
+                        }
+                        // ─── DELETE ─────────────────────────────────
+                        case 'delete': {
+                            // Remove the individual-item cache entry
+                            queryClient.removeQueries({ queryKey: [entityKey, id], exact: true });
+                            // Remove from every active list / infinite-query cache
+                            queryClient.setQueriesData({ predicate: entityPredicate, type: 'active' }, (old) => {
+                                if (!old)
+                                    return old;
+                                if (old.pages && Array.isArray(old.pages)) {
+                                    return {
+                                        ...old,
+                                        pages: old.pages.map((page) => page.filter((x) => x?.id !== id)),
+                                    };
+                                }
+                                if (Array.isArray(old)) {
+                                    return old.filter((x) => x?.id !== id);
+                                }
+                                return old;
+                            });
+                            break;
+                        }
+                    }
+                    // Invalidate any additional keys (e.g. companies → /company/list)
+                    alsoInvalidate?.forEach((k) => queryClient.invalidateQueries({ queryKey: k }));
+                };
+                this.socket.on(event, handler);
+                handlers.push({ event, handler });
+            }
         }
         // Auto join/leave company room
         const joinCompanyRoom = () => {

package/dist/types/api/Task.js

@@ -44,7 +44,7 @@ export class Task {
                 return "< 1d overdue";
             }
             else {
-                return `${Math.floor(this.overdueness / 86400)}d overdue`;
+                return `${Math.floor(this.overdue_time / 86400)}d overdue`;
             }
         };
         this.getNextDue = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-avro/avro-js",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "JS client for Avro backend integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",