goby-database 2.2.28 → 2.2.30

package/dist/index.d.ts

@@ -70,12 +70,31 @@ export default class Project {
     delete_item_from_root(id: number): void;
     action_set_root_item_value(id: number, value: string): void;
     lookup_class(class_id: number): ClassData;
-    action_add_row(class_id: number): number;
+    /**
+     * Creates a new item and adds it to the class you indicate
+     * @param class_id - class you want to add new item to
+     * @param property_values - any properties you want to fill in as you create this item (data props only for now)
+     * @returns - id of new item
+     */
+    action_add_row(class_id: number, property_values?: {
+        property_id: number;
+        value: any;
+    }[]): number;
     get_next_order(table_name: string): number;
-    action_set_property_values(class_id: number, item_id: number, changes: {
+    /**
+     * Sets 1 or more data property values for a given class item.
+     * @param class_id - class of item
+     * @param item_id - id of item
+     * @param changes - array of data properties to be set
+     */
+    action_edit_item_data(class_id: number, item_id: number, changes: {
         property_id: number;
         value: any;
     }[]): void;
+    /**
+     * Adds/removes relations between items/item properties
+     * @param relations - list of pairs of items for which relations should be added or removed between specified properties
+     */
     action_edit_relations(relations: {
         change: 'add' | 'remove';
         sides: [input_1: ItemRelationSide, input_2: ItemRelationSide];

package/dist/index.js

@@ -1,8 +1,5 @@
 import Database from 'better-sqlite3';
-import { defined, partial_relation_match, full_relation_match, can_have_multiple_values, junction_col_name, side_match, two_way, edit_has_valid_sides, readable_edit } from './utils.js';
-const text_data_types = ['string', 'resource'];
-const integer_data_types = ['boolean'];
-const real_data_types = ['number'];
+import { defined, partial_relation_match, full_relation_match, can_have_multiple_values, junction_col_name, side_match, two_way, edit_has_valid_sides, readable_edit, text_data_types, integer_data_types, real_data_types, validate_data_value } from './utils.js';
 export default class Project {
     constructor(source) {
         this.class_cache = [];
@@ -17,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'),
@@ -689,14 +687,42 @@ export default class Project {
             throw new Error('Cannot find class in class list.');
         return class_data;
     }
-    action_add_row(class_id) {
+    /**
+     * Creates a new item and adds it to the class you indicate
+     * @param class_id - class you want to add new item to
+     * @param property_values - any properties you want to fill in as you create this item (data props only for now)
+     * @returns - id of new item
+     */
+    action_add_row(class_id, property_values = []) {
         const class_data = this.lookup_class(class_id);
         let class_name = class_data.name;
         //first add new row to root and get id
         const root_id = this.create_item_in_root({ type: 'class_' + class_id });
+        // NOTE: I will need a second handler in the future if I want to support relation props here
+        // (probably utilizing action_edit_relations)
+        const data_property_sql = property_values.reduce((obj, current) => {
+            const corresponding_prop = class_data.properties.find((prop) => {
+                return prop.id == current.property_id;
+            });
+            if ((corresponding_prop === null || corresponding_prop === void 0 ? void 0 : corresponding_prop.type) == 'data') {
+                const validated = validate_data_value(current.value, corresponding_prop.data_type, corresponding_prop.max_values);
+                if (validated.valid) {
+                    const v = text_data_types.includes(corresponding_prop.data_type) ? `'${validated.output}'` : validated.output;
+                    obj.columns += `, [user_${corresponding_prop.name}]`;
+                    obj.values += `, ${v}`;
+                }
+                else {
+                    console.log(`Did not modify ${corresponding_prop.name} for item: ${validated.message}`);
+                }
+            }
+            return obj;
+        }, {
+            columns: '',
+            values: ''
+        });
         //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.db.prepare(`INSERT INTO [class_${class_name}] (system_id, system_order${data_property_sql.columns}) VALUES (${root_id},${new_order}${data_property_sql.values})`).run();
         return root_id;
     }
     get_next_order(table_name) {
@@ -704,15 +730,21 @@ export default class Project {
         const new_order = last_ordered_item ? last_ordered_item.system_order + 1000 : 0;
         return new_order;
     }
-    // NOTE: seems like there should be a way to pair down "value:any" in params, maybe at least make it one of a few value types
-    action_set_property_values(class_id, item_id, changes) {
+    /**
+     * Sets 1 or more data property values for a given class item.
+     * @param class_id - class of item
+     * @param item_id - id of item
+     * @param changes - array of data properties to be set
+     */
+    action_edit_item_data(class_id, item_id, changes) {
+        // NOTE: seems like there should be a way to pair down "value:any" in params, maybe at least make it one of a few value types
         const class_data = this.lookup_class(class_id);
         const sql_column_inserts = [];
         for (let change of changes) {
             const prop_data = class_data.properties.find((p) => p.id == change.property_id);
             if (prop_data && prop_data.type == 'data') {
                 // const data_type=prop_data.data_type;
-                const cell_value = validate(change.value, prop_data.data_type, prop_data.max_values);
+                const cell_value = validate_data_value(change.value, prop_data.data_type, prop_data.max_values);
                 if (cell_value.valid) {
                     sql_column_inserts.push({
                         column_name: `[user_${prop_data.name}]`,
@@ -731,47 +763,11 @@ 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);
-        function validate(input, data_type, max_values) {
-            const multiple = max_values == null || max_values > 1;
-            const values = multiple ? input : [input];
-            if (!Array.isArray(values)) {
-                return { valid: false, message: 'Expecting array, got single value' };
-            }
-            const validated_values = [];
-            for (let value of values) {
-                if (real_data_types.includes(data_type) || integer_data_types.includes(data_type)) {
-                    if (data_type == 'boolean') {
-                        if (typeof value == 'boolean' || [0, 1].includes(value)) {
-                            validated_values.push(+value);
-                        }
-                        else {
-                            return { valid: false, message: `Expecting boolean or binary integer, got "${value}" (${typeof value})` };
-                        }
-                    }
-                    else if (typeof value == 'number') {
-                        validated_values.push(value);
-                    }
-                    else {
-                        return { valid: false, message: `Expecting number, got "${value}" (${typeof value})` };
-                    }
-                }
-                else if (text_data_types.includes(data_type)) {
-                    // NOTE: could come back to validate resource as links/filepaths later, but leaving unopinionated for now
-                    if (typeof value == 'string') {
-                        validated_values.push(value);
-                    }
-                    else {
-                        return { valid: false, message: `Expecting string, got "${value}" (${typeof value})` };
-                    }
-                }
-            }
-            const output = multiple ? JSON.stringify(validated_values) : validated_values[0];
-            return {
-                valid: true,
-                output
-            };
-        }
     }
+    /**
+     * Adds/removes relations between items/item properties
+     * @param relations - list of pairs of items for which relations should be added or removed between specified properties
+     */
     action_edit_relations(relations) {
         // NOTE: changes to make to this in the future:
         //  - for input readability, allow class_name and prop_name as input options, assuming they’re enforced as unique, and use them to look up IDs
@@ -808,27 +804,29 @@ export default class Project {
     }
     // 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;
@@ -843,22 +841,51 @@ 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 
@@ -875,7 +902,7 @@ 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(` 
@@ -887,30 +914,28 @@ export default class Project {
 
                 )`;
                 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}`;
-        console.log('query', query);
         // 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();
         let stringified_properties = class_data.properties.filter(a => a.type == 'relation' || can_have_multiple_values(a.max_values));

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/dist/utils.d.ts

@@ -1,5 +1,8 @@
-import { JunctionSides, RelationshipSide, MaxValues, RelationshipSideBase, RelationEdit, RelationEditValidSides, ClassData, JunctionList } from "./types.js";
+import { JunctionSides, RelationshipSide, MaxValues, RelationshipSideBase, RelationEdit, RelationEditValidSides, ClassData, JunctionList, DataType } from "./types.js";
 export declare function defined<T>(v: T): v is NonNullable<T>;
+export declare const text_data_types: string[];
+export declare const integer_data_types: string[];
+export declare const real_data_types: string[];
 export declare function partial_relation_match(old_relation: JunctionSides, new_relation: JunctionSides): boolean;
 export declare function side_match(x: RelationshipSide, y: RelationshipSide): boolean;
 export declare function full_relation_match(a: JunctionSides, b: JunctionSides): boolean;
@@ -11,3 +14,10 @@ export declare function junction_col_name(class_id: number, prop_id: number | un
 export declare function readable_side(side: RelationshipSide, classlist: ClassData[]): string;
 export declare function readable_edit(edit: RelationEditValidSides, classlist: ClassData[]): string | undefined;
 export declare function readable_junctionlist(relationships: JunctionList, classlist: ClassData[]): string[];
+export declare function validate_data_value(input: any, data_type: DataType, max_values: MaxValues): {
+    valid: true;
+    output: string | number;
+} | {
+    valid: false;
+    message: string;
+};

package/dist/utils.js

@@ -1,6 +1,9 @@
 export function defined(v) {
     return v !== undefined && v !== null;
 }
+export const text_data_types = ['string', 'resource'];
+export const integer_data_types = ['boolean'];
+export const real_data_types = ['number'];
 // given the type above,
 // check if two relations share class ids on both sides
 // and share a property id on at least one side
@@ -103,4 +106,44 @@ export function readable_junctionlist(relationships, classlist) {
         return readable_sides(r.sides, classlist);
     });
 }
+export function validate_data_value(input, data_type, max_values) {
+    const multiple = max_values == null || max_values > 1;
+    const values = multiple ? input : [input];
+    if (!Array.isArray(values)) {
+        return { valid: false, message: 'Expecting array, got single value' };
+    }
+    const validated_values = [];
+    for (let value of values) {
+        if (real_data_types.includes(data_type) || integer_data_types.includes(data_type)) {
+            if (data_type == 'boolean') {
+                if (typeof value == 'boolean' || [0, 1].includes(value)) {
+                    validated_values.push(+value);
+                }
+                else {
+                    return { valid: false, message: `Expecting boolean or binary integer, got "${value}" (${typeof value})` };
+                }
+            }
+            else if (typeof value == 'number') {
+                validated_values.push(value);
+            }
+            else {
+                return { valid: false, message: `Expecting number, got "${value}" (${typeof value})` };
+            }
+        }
+        else if (text_data_types.includes(data_type)) {
+            // NOTE: could come back to validate resource as links/filepaths later, but leaving unopinionated for now
+            if (typeof value == 'string') {
+                validated_values.push(value);
+            }
+            else {
+                return { valid: false, message: `Expecting string, got "${value}" (${typeof value})` };
+            }
+        }
+    }
+    const output = multiple ? JSON.stringify(validated_values) : validated_values[0];
+    return {
+        valid: true,
+        output
+    };
+}
 //# sourceMappingURL=utils.js.map

package/package.json

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