goby-database 2.2.29 → 2.2.31

package/dist/index.d.ts

@@ -97,7 +97,11 @@ export default class Project {
      */
     action_edit_relations(relations: {
         change: 'add' | 'remove';
-        sides: [input_1: ItemRelationSide, input_2: ItemRelationSide];
+        sides: [input_1: ItemRelationSide & {
+            order?: number;
+        }, input_2: ItemRelationSide & {
+            order?: number;
+        }];
     }[]): void;
     retrieve_class_items({ class_id, class_name, class_data, pagination }: {
         class_id: number;

package/dist/index.js

@@ -14,7 +14,8 @@ export default class Project {
         else {
             console.log('opened goby database');
         }
-        //prepared statements with arguments so my code isn't as verbose elsewhere
+        // prepared statements with arguments so my code isn't as verbose elsewhere
+        // obviously can only do this for actions on determinate columns
         this.run = {
             begin: this.db.prepare('BEGIN IMMEDIATE'),
             commit: this.db.prepare('COMMIT'),
@@ -598,12 +599,20 @@ export default class Project {
         let id = (_a = this.db.prepare('SELECT id FROM system_junctionlist ORDER BY id DESC').get()) === null || _a === void 0 ? void 0 : _a.id;
         if (typeof id !== 'number')
             throw new Error('Something went wrong creating a new relationship');
+        const side_0_col = junction_col_name(sides[0].class_id, sides[0].prop_id);
+        const side_1_col = junction_col_name(sides[1].class_id, sides[1].prop_id);
+        const columns = [
+            `"${side_0_col}" INTEGER`,
+            `"${side_1_col}" INTEGER`,
+        ];
+        // for each side, check if it has a prop
+        // if it does, add column for its order
+        if (defined(sides[0].prop_id))
+            columns.push(`"${side_0_col}_order" REAL`);
+        if (defined(sides[1].prop_id))
+            columns.push(`"${side_1_col}_order" REAL`);
         // creates table
-        this.create_table('junction', id, [
-            `"${junction_col_name(sides[0].class_id, sides[0].prop_id)}" INTEGER`,
-            `"${junction_col_name(sides[1].class_id, sides[1].prop_id)}" INTEGER`,
-            `date_added INTEGER`
-        ]);
+        this.create_table('junction', id, columns);
         return id;
     }
     transfer_connections(source, target) {
@@ -779,51 +788,98 @@ export default class Project {
                 input_2: junction_col_name(input_2.class_id, input_2.prop_id)
             };
             const junction_id = (_a = this.junction_cache.find(j => full_relation_match(j.sides, [input_1, input_2]))) === null || _a === void 0 ? void 0 : _a.id;
-            if (junction_id) {
-                if (change == 'add') {
-                    const date_added = Date.now();
-                    this.db.prepare(`
-                        INSERT INTO junction_${junction_id} 
-                        ("${column_names.input_1}", "${column_names.input_2}",date_added) 
-                        VALUES (${input_1.item_id},${input_2.item_id},${date_added})
-                    `).run();
-                }
-                else if (change == 'remove') {
-                    this.db.prepare(`
-                        DELETE FROM junction_${junction_id} 
-                        WHERE "${column_names.input_1}" = ${input_1.item_id}
-                        AND "${column_names.input_2}" = ${input_2.item_id}`).run();
-                }
-            }
-            else {
+            if (!defined(junction_id)) {
                 throw Error('Something went wrong - junction table for relationship not found');
             }
+            if (change == 'add') {
+                const column_value_set = [
+                    {
+                        column: `"${column_names.input_1}"`,
+                        value: input_1.item_id
+                    },
+                    {
+                        column: `"${column_names.input_2}"`,
+                        value: input_2.item_id
+                    }
+                ];
+                sides.forEach((side, s) => {
+                    var _a, _b, _c;
+                    // for each side, check if it has a prop id
+                    if (defined(side.prop_id)) {
+                        // if it does, prepare to add a column entry for it
+                        const column = `"${s == 0 ? column_names.input_1 : column_names.input_2}_order"`;
+                        let value = 0;
+                        // check if it has an order set
+                        if (defined(side.order)) {
+                            // if so, use that for the column entry
+                            value = side.order;
+                        }
+                        else {
+                            // if not, you have to do a lookup of that property value for that item, and get the last order value
+                            const class_data = this.lookup_class(side.class_id);
+                            const item = (_a = this.retrieve_class_items({
+                                class_id: side.class_id,
+                                class_data,
+                                pagination: {
+                                    item_range: [side.item_id],
+                                    property_range: [side.prop_id]
+                                }
+                            }).loaded) === null || _a === void 0 ? void 0 : _a[0];
+                            const prop_name = (_b = class_data.properties.find((p) => p.id == side.prop_id)) === null || _b === void 0 ? void 0 : _b.name;
+                            const prop_selections = defined(prop_name) && item ? item[`user_${prop_name}`] : [];
+                            if (Array.isArray(prop_selections)) {
+                                const last_item_order = (_c = prop_selections === null || prop_selections === void 0 ? void 0 : prop_selections.at(-1)) === null || _c === void 0 ? void 0 : _c.system_order;
+                                if (typeof last_item_order == 'number') {
+                                    value = last_item_order + 1000;
+                                }
+                            }
+                        }
+                        column_value_set.push({
+                            column,
+                            value
+                        });
+                    }
+                });
+                this.db.prepare(`
+                    INSERT INTO junction_${junction_id} 
+                    (${column_value_set.map((a) => a.column).join(',')}) 
+                    VALUES (${column_value_set.map((a) => a.value).join(',')})
+                `).run();
+            }
+            else if (change == 'remove') {
+                this.db.prepare(`
+                    DELETE FROM junction_${junction_id} 
+                    WHERE "${column_names.input_1}" = ${input_1.item_id}
+                    AND "${column_names.input_2}" = ${input_2.item_id}`).run();
+            }
         }
         // NOTE: should this trigger a refresh to items?
     }
     // MARKER: modify item retrieval
     retrieve_class_items({ class_id, class_name, class_data, pagination = {} }) {
+        // 1. DETERMINE COLUMNS AND ROWS TO RETRIEVE ---------------------------------------------------
         var _a, _b, _c, _d, _e;
         const pagination_defaults = {
             page_size: null,
             property_range: 'all',
-            item_range: 'all'
+            item_range: 'all',
+            conditions: []
         };
+        // set pagination rules by overriding defaults with any custom settings
         pagination = Object.assign(Object.assign({}, pagination_defaults), pagination);
+        // get class data+name if not already passed in
         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
-        const cte_strings = [];
-        // joined+added near the end of the query, built from relations
-        const cte_joins = [];
-        // joined+added between SELECT and FROM, built from relations
-        const relation_selections = [];
+        // gets the label prop for this class
         const label_prop_ids = (_b = (_a = class_data.metadata.label) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : [];
-        // if a property_range is defined, first filter class_data.properties by those IDs
+        const where_conditions = [];
+        if (pagination.item_range && pagination.item_range !== 'all') {
+            where_conditions.push(`system_id in (${pagination.item_range.join(',')})`);
+        }
+        // if a property_range is defined, first filter properties retrieved by those IDs
         const retrieved_properties = class_data.properties.filter((prop) => {
             if (pagination.property_range == 'all' || !pagination.property_range) {
                 return true;
@@ -838,27 +894,61 @@ export default class Project {
                 return true;
             }
         });
+        const cte_properties = [];
+        for (let condition of (pagination.conditions || [])) {
+            if (condition.name == 'under_property_max') {
+                const property = class_data.properties.find((p) => p.id == condition.property_id);
+                if ((property === null || property === void 0 ? void 0 : property.type) == 'relation' && property.max_values !== null) {
+                    if (!cte_properties.some((p) => p.id == condition.property_id) && !retrieved_properties.some((p) => p.id == condition.property_id)) {
+                        // if this property isn’t retrieved directly, we have to make sure a CTE is created for it, just so we can count the values
+                        cte_properties.push(Object.assign(Object.assign({}, property), { cte_only: true }));
+                    }
+                    // add a condition that counts the items selected by this item for this property
+                    where_conditions.push(`COALESCE([count_user_${property.name}],0) < ${property.max_values}`);
+                }
+            }
+        }
+        // separates these, since they are handled separately in the query
         const relation_properties = retrieved_properties.filter(a => a.type == 'relation');
         const data_properties = retrieved_properties.filter(a => a.type == 'data');
-        for (let prop of relation_properties) {
+        // 2. GENERATE SQLITE QUERY --------------------------------------------------
+        // class table name in db
+        const class_string = `[class_${class_name}]`;
+        // 2a. Handle relation properties by generating common table expressions (ctes)
+        // joined+added at beginning of the query, built from relations
+        const cte_strings = [];
+        // joined+added near the end of the query, built from relations
+        const cte_joins = [];
+        // joined+added between SELECT and FROM, built from relations
+        const relation_selections = [];
+        for (let prop of [...relation_properties, ...cte_properties]) {
             const target_selects = [];
-            let property_junction_column_name = junction_col_name(class_id, prop.id);
+            // name of column for this class/property in junction table
+            const property_junction_column_name = junction_col_name(class_id, prop.id);
+            // loop through each target
             if (prop.relation_targets.length > 0) {
                 for (let i = 0; i < prop.relation_targets.length; i++) {
                     // find the side that does not match both the class and prop IDs
-                    let target = prop.relation_targets[i];
+                    const target = prop.relation_targets[i];
                     const target_class = this.class_cache.find((a) => a.id == (target === null || target === void 0 ? void 0 : target.class_id));
                     if (target && target_class) {
+                        // target column name in junction table
                         let target_junction_column_name = junction_col_name(target.class_id, target.prop_id);
-                        // NOTE: as mentioned elsewhere, possibly allow multiple label props
+                        // get label of label property in target prop
                         const target_label_id = (_d = (_c = target_class === null || target_class === void 0 ? void 0 : target_class.metadata) === null || _c === void 0 ? void 0 : _c.label) === null || _d === void 0 ? void 0 : _d.properties[0];
                         const target_label = target_class === null || target_class === void 0 ? void 0 : target_class.properties.find((p) => p.id == target_label_id);
                         const label_sql_string = target_label ? `,'user_${target_label.name}',target_class."user_${target_label.name}"` : '';
+                        // NOTE: as mentioned elsewhere, possibly allow multiple label props
                         let junction_id = target.junction_id;
                         let target_select = `
                         SELECT 
                             "${property_junction_column_name}", 
-                            json_object('class_id',${target.class_id},'system_id',junction."${target_junction_column_name}"${label_sql_string}) AS target_data, junction.date_added AS date_added
+                            json_object(
+                                'class_id',${target.class_id},
+                                'system_id',junction."${target_junction_column_name}",
+                                'system_order',junction."${property_junction_column_name}_order"
+                                ${label_sql_string}
+                            ) AS target_data, junction."${property_junction_column_name}_order" AS relation_order
                             FROM junction_${junction_id} AS junction
                             LEFT JOIN "class_${target_class === null || target_class === void 0 ? void 0 : target_class.name}" AS target_class ON junction."${target_junction_column_name}" =  target_class.system_id
                         `;
@@ -870,40 +960,39 @@ export default class Project {
                 }
                 // uses built-in aggregate json function instead of group_concat craziness
                 const cte = `[${prop.id}_cte] AS (
-                    SELECT "${property_junction_column_name}", json_group_array( json(target_data) ) AS [user_${prop.name}]
+                    SELECT "${property_junction_column_name}", json_group_array( json(target_data) ) AS [user_${prop.name}], COUNT(1) AS [count_user_${prop.name}]
                     FROM 
                     (
                         ${target_selects.join(` 
                         UNION 
                         `)}
-                        ORDER BY date_added
+                        ORDER BY relation_order
                     )
                     GROUP BY "${property_junction_column_name}"
 
                 )`;
                 cte_strings.push(cte);
-                relation_selections.push(`[${prop.id}_cte].[user_${prop.name}]`);
+                if (!("cte_only" in prop && prop.cte_only))
+                    relation_selections.push(`[${prop.id}_cte].[user_${prop.name}]`);
                 cte_joins.push(`LEFT JOIN [${prop.id}_cte] ON [${prop.id}_cte]."${property_junction_column_name}" = ${class_string}.system_id`);
             }
             else {
-                relation_selections.push(`'[]' AS [user_${prop.name}]`);
+                if (!("cte_only" in prop && prop.cte_only))
+                    relation_selections.push(`'[]' AS [user_${prop.name}]`);
             }
         }
         let orderby = `ORDER BY ${class_string}.system_order`;
         const data_prop_sql_string = data_properties.length > 0 ? ', ' + data_properties.map((p) => `[user_${p.name}]`).join(',') : '';
         const table_selection = pagination.property_range == 'all' ? `[class_${class_name}].*` : `system_id,system_order${data_prop_sql_string}`;
-        let filter_by_items = '';
-        if (pagination.item_range && pagination.item_range !== 'all') {
-            filter_by_items = `WHERE system_id in (${pagination.item_range.join(',')})`;
-        }
-        let comma_break = `,
+        const where_string = where_conditions.length > 0 ? `WHERE ${where_conditions.map((w) => `(${w})`).join(' AND ')}` : '';
+        const comma_break = `,
             `;
         let query = `
             ${cte_strings.length > 0 ? "WITH " + cte_strings.join(comma_break) : ''}
             SELECT ${table_selection} ${relation_selections.length > 0 ? ', ' + relation_selections.join(`, `) : ''}
             FROM [class_${class_name}]
             ${cte_joins.join(' ')}
-            ${filter_by_items}
+            ${where_string}
             ${orderby}`;
         // possibly elaborate this any type a little more in the future, e.g. a CellValue or SQLCellValue type that expects some wildcards
         let items = this.db.prepare(query).all();

package/dist/types.d.ts

@@ -142,6 +142,10 @@ export type ClassData = {
     properties: Property[];
 };
 export type ClassList = ClassData[];
+type ConditionUnderPropertyMax = {
+    name: 'under_property_max';
+    property_id: number;
+};
 export type ItemPagination = {
     page_size?: number | null;
     page_range?: [start: number, end?: number];
@@ -149,6 +153,7 @@ export type ItemPagination = {
     property_range?: number[] | 'slim' | 'all';
     /** Filter by item IDs. If not specified, pulls all */
     item_range?: number[] | 'all';
+    conditions?: ConditionUnderPropertyMax[];
 };
 export type PaginatedItems = ItemPagination & {
     loaded: ClassRow[];

package/package.json

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