goby-database 2.1.19 → 2.1.21

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { Database as DatabaseType, Statement } from 'better-sqlite3';
-import type { SQLTableType, SQLClassListRow, SQLJunctonListRow, JunctionSides, JunctionList, ClassList, Property, DataType, ItemRelationSide, SQLApplicationWindow, ApplicationWindow, WorkspaceBlock, ClassData, ClassRow, ClassEdit, RelationEdit, PropertyEdit, MaxValues, PropertyType, RelationProperty, DataProperty, RelationEditValidSides } from './types.js';
+import type { SQLTableType, SQLClassListRow, SQLJunctonListRow, JunctionSides, JunctionList, ClassList, Property, DataType, ItemRelationSide, SQLApplicationWindow, ApplicationWindow, WorkspaceBlock, ClassData, ClassEdit, RelationEdit, PropertyEdit, MaxValues, PropertyType, RelationProperty, DataProperty, RelationEditValidSides, ItemPagination, PaginatedItems } from './types.js';
 export default class Project {
     db: DatabaseType;
     run: {
@@ -19,10 +19,6 @@ export default class Project {
         }>;
     };
     class_cache: ClassList;
-    item_cache: {
-        class_id: number;
-        items: ClassRow[];
-    }[];
     junction_cache: JunctionList;
     constructor(source: string);
     get_latest_table_row_id(table_name: string): number | null;
@@ -81,13 +77,19 @@ export default class Project {
         value: any;
     }[]): void;
     action_make_relations(relations: [input_1: ItemRelationSide, input_2: ItemRelationSide][]): void;
-    retrieve_class_items({ class_id, class_name, class_data, slim }: {
+    retrieve_class_items({ class_id, class_name, class_data, pagination }: {
         class_id: number;
         class_name?: string;
         class_data?: ClassData;
-        slim?: boolean;
-    }): ClassRow[];
-    retrieve_all_classes(): ClassData[];
+        pagination?: ItemPagination;
+    }): PaginatedItems;
+    retrieve_all_classes(include?: {
+        all_items?: ItemPagination;
+        items_by_class?: {
+            class_id: number;
+            pagination: ItemPagination;
+        }[];
+    }): ClassData[];
     parse_sql_prop(class_id: number, sql_prop: {
         id: number;
         type: PropertyType;

package/dist/index.js

@@ -6,7 +6,6 @@ const real_data_types = ['number'];
 export default class Project {
     constructor(source) {
         this.class_cache = [];
-        this.item_cache = [];
         this.junction_cache = [];
         this.db = new Database(source);
         //checks if goby has been initialized, initializes if not
@@ -52,7 +51,7 @@ export default class Project {
             create_window: this.db.prepare(`INSERT INTO system_windows (type,open, metadata) VALUES (@type, @open, @meta)`),
             get_windows: this.db.prepare(`SELECT id, type, open, metadata FROM system_windows`)
         };
-        this.refresh_caches(['classlist', 'items', 'junctions']);
+        this.refresh_caches(['classlist', 'junctions']);
         // commenting this out until I figure out my transaction / one-step-undo functionality
         //if I understand transactions correctly, a new one will begin with every user action while committing the one before, meaning I'll need to have the first begin here
         // this.run.begin.run();
@@ -108,19 +107,6 @@ export default class Project {
         if (caches.includes('classlist')) {
             this.class_cache = this.retrieve_all_classes();
         }
-        if (caches.includes('items')) {
-            let refreshed_items = [];
-            for (let class_data of this.class_cache) {
-                // NOTE: add pagination to this
-                let items = this.retrieve_class_items({ class_id: class_data.id });
-                refreshed_items.push({
-                    class_id: class_data.id,
-                    items
-                });
-                class_data.items = items;
-            }
-            this.item_cache = refreshed_items;
-        }
         if (caches.includes('junctions')) {
             this.junction_cache = this.get_junctions();
         }
@@ -710,7 +696,6 @@ export default class Project {
         //get the last item in class table order and use it to get the order for the new item
         const new_order = this.get_next_order(`[class_${class_name}]`);
         this.db.prepare(`INSERT INTO [class_${class_name}] (system_id, system_order) VALUES (${root_id},${new_order})`).run();
-        this.refresh_caches(['items']);
         return root_id;
     }
     get_next_order(table_name) {
@@ -745,7 +730,6 @@ export default class Project {
         const set_statements = sql_column_inserts.map((p) => `${p.column_name} = ?`).join(',');
         const insert_statement = `UPDATE [class_${class_data.name}] SET ${set_statements} WHERE system_id=${item_id}`;
         this.db.prepare(insert_statement).run(params);
-        this.refresh_caches(['items']);
         function validate(input, data_type, max_values) {
             const multiple = max_values == null || max_values > 1;
             const values = multiple ? input : [input];
@@ -809,23 +793,30 @@ export default class Project {
                 throw Error('Something went wrong - junction table for relationship not found');
             }
         }
-        this.refresh_caches(['items']);
         // NOTE: should this trigger a refresh to items?
     }
-    retrieve_class_items({ class_id, class_name, class_data, slim = false }) {
-        var _a, _b, _c, _d;
+    // MARKER: modify item retrieval
+    retrieve_class_items({ class_id, class_name, class_data, pagination = {} }) {
+        var _a, _b, _c, _d, _e;
+        const pagination_defaults = {
+            page_size: null,
+            property_range: 'all'
+        };
+        pagination = Object.assign(Object.assign({}, pagination_defaults), pagination);
+        const slim = pagination.property_range == 'slim';
         if (class_name == undefined || class_data == undefined) {
             class_data = this.lookup_class(class_id);
             class_name = class_data.name;
         }
         ;
         const class_string = `[class_${class_name}]`;
-        // //joined+added at beginning of the query, built from relations
+        // joined+added at beginning of the query, built from relations
         const cte_strings = [];
-        // //joined+added near the end of the query, built from relations
+        // joined+added near the end of the query, built from relations
         const cte_joins = [];
-        // //joined+added between SELECT and FROM, built from relations
+        // joined+added between SELECT and FROM, built from relations
         const relation_selections = [];
+        // NOTE: in the future, if a property_range is defined, first filter class_data.properties by those IDs
         let relation_properties = class_data.properties.filter(a => a.type == 'relation');
         if (!slim) {
             for (let prop of relation_properties) {
@@ -905,19 +896,29 @@ export default class Project {
                 }
             }
         });
-        return items;
+        let total = (_e = this.db.prepare(`SELECT COUNT(1) AS total FROM ${class_string}`).all()[0]) === null || _e === void 0 ? void 0 : _e.total;
+        return Object.assign(Object.assign({}, pagination), { loaded: items, total });
     }
-    retrieve_all_classes() {
+    // MARKER: modify item retrieval
+    retrieve_all_classes(include = {}) {
         const classes_data = this.run.get_all_classes.all();
         return classes_data.map(({ id, name, metadata }) => {
-            var _a;
-            let existing_items = this.item_cache.find((itemlist) => itemlist.class_id == id);
+            var _a, _b, _c;
             let properties_sql = this.db.prepare(`SELECT * FROM class_${id}_properties`).all() || [];
             let properties = properties_sql.map((sql_prop) => this.parse_sql_prop(id, sql_prop));
+            const pagination = (_a = include.all_items) !== null && _a !== void 0 ? _a : (_c = (_b = include.items_by_class) === null || _b === void 0 ? void 0 : _b.find(((a) => a.class_id == id))) === null || _c === void 0 ? void 0 : _c.pagination;
+            const items = pagination ? this.retrieve_class_items({
+                class_id: id,
+                class_name: name,
+                pagination
+            }) : {
+                loaded: [],
+                total: 0
+            };
             return {
                 id,
                 name,
-                items: (_a = existing_items === null || existing_items === void 0 ? void 0 : existing_items.items) !== null && _a !== void 0 ? _a : [],
+                items,
                 properties,
                 metadata: JSON.parse(metadata)
             };
@@ -974,9 +975,15 @@ export default class Project {
             ON system_root.id = workspace_${id}.thing_id
             WHERE workspace_${id}.type = 'item';
         `).all();
+        // MARKER: modify item retrieval
         // get any relevant classes
-        const classes = this.class_cache.filter((cls) => blocks.some((block) => block.type == 'class' && block.thing_id == cls.id));
-        // NOTE: could possibly add class items as well in the future
+        const items_by_class = blocks.filter((b) => b.type == 'class').map((b) => ({
+            class_id: b.thing_id,
+            pagination: {
+                page_size: null
+            }
+        }));
+        const classes = this.retrieve_all_classes({ items_by_class });
         return {
             blocks,
             items,

package/dist/types.d.ts

@@ -135,10 +135,20 @@ export type ClassData = {
     id: number;
     name: string;
     metadata: ClassMetadata;
-    items: ClassRow[];
+    items: PaginatedItems;
     properties: Property[];
 };
 export type ClassList = ClassData[];
+export type ItemPagination = {
+    page_size?: number | null;
+    page_range?: [start: number, end?: number];
+    property_range?: number[] | 'slim' | 'all';
+};
+export type PaginatedItems = ItemPagination & {
+    loaded: ClassRow[];
+    /** a count of all the items in the class, not just those loaded */
+    total: number;
+};
 export type JunctionSides = [RelationshipSide, RelationshipSide];
 export type JunctionTable = {
     id: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goby-database",
-  "version": "2.1.19",
+  "version": "2.1.21",
   "description": "This will hold the core better-sqlite3-powered application for creating and modifying goby databases",
   "main": "dist/index.js",
   "files": [