tywalch / electrodb / 381

pending completion

Build # 381

Build Type

Pull #198

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/tywalch/electrodb/commit/<a class=hub.com/tywalch/electrodb/commit/<a class="double-link" href="https://git"><a class=hub.com/tywalch/electrodb/commit/<a class="double-link" href="https://git"><a class=hub.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb3b6fa920">59eeda083<a href="https://github.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb3b6fa920">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tywalch/electrodb/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tywalch/electrodb/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb3b6fa920&quot;&gt;59eeda083&lt;/a&gt;&lt;a href=&quot;https://github.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb3b6fa920&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb&lt;/a&gt;3b6fa920">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tywalch/electrodb/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tywalch/electrodb/commit/<a class="double-link" href="https://github.com/tywalch/electrodb/commit/8aa1dae6310a1c257039a5ed46fe1ce314f8316c">8aa1dae63</a><a href="https://github.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb3b6fa920">&amp;quot;&amp;gt;8aa1dae63&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;8aa1dae63&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/tywalch/electrodb/commit/59eeda0837c29be942fd5c6fdc4c3dfb3b6fa&lt;/a&gt;920&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tywalch/electrodb/commit/<a class="double-link" href="https://github.com/tywalch/electrodb/commit/4ebdc4cd2">4ebdc4cd2">4ebdc4cd2</a>

Pull Request Pull Request #198: Updating error link references

Run Details

1700 of 2189 branches covered (77.66%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 5 files covered. (100.0%)

3054 of 3369 relevant lines covered (90.65%)

2867.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.72

/src/operations.js

const {AttributeTypes, ItemOperations, AttributeProxySymbol, BuilderTypes} = require("./types");
const e = require("./errors");
const u = require("./util");

const deleteOperations = {
    canNest: false,
    template: function del(options, attr, path, value) {
        let operation = "";
        let expression = "";
        switch(attr.type) {
            case AttributeTypes.any:
            case AttributeTypes.set:
                operation = ItemOperations.delete;
                expression = `${path} ${value}`;
                break;
            default:
                throw new Error(`Invalid Update Attribute Operation: "DELETE" Operation can only be performed on attributes with type "set" or "any".`);
        }
        return {operation, expression};
    },
};

const UpdateOperations = {
    ifNotExists: {
        template: function if_not_exists(options, attr, path, value) {
            const operation = ItemOperations.set;
            const expression = `${path} = if_not_exists(${path}, ${value})`;
            return {operation, expression};
        }
    },
    name: {
        canNest: true,
        template: function name(options, attr, path) {
            return path;
        }
    },
    value: {
        canNest: true,
        template: function value(options, attr, path, value) {
            return value;
        }
    },
    append: {
        canNest: false,
        template: function append(options, attr, path, value) {
            let operation = "";
            let expression = "";
            switch(attr.type) {
                case AttributeTypes.any:
                case AttributeTypes.list:
                    operation = ItemOperations.set;
                    expression = `${path} = list_append(${path}, ${value})`;
                    break;
                default:
                    throw new Error(`Invalid Update Attribute Operation: "APPEND" Operation can only be performed on attributes with type "list" or "any".`);
            }
            return {operation, expression};
        }
    },
    add: {
        canNest: false,
        template: function add(options, attr, path, value) {
            let operation = "";
            let expression = "";
            let type = attr.type;
            if (type === AttributeTypes.any) {
                type = typeof value === 'number'
                    ? AttributeTypes.number
                    : AttributeTypes.any;
            }
            switch(type) {
                case AttributeTypes.any:
                case AttributeTypes.set:
                    operation = ItemOperations.add;
                    expression = `${path} ${value}`;
                    break;
                case AttributeTypes.number:
                    if (options.nestedValue) {
                        operation = ItemOperations.set;
                        expression = `${path} = ${path} + ${value}`;
                    } else {
                        operation = ItemOperations.add;
                        expression = `${path} ${value}`;
                    }
                    break;
                default:
                    throw new Error(`Invalid Update Attribute Operation: "ADD" Operation can only be performed on attributes with type "number", "set", or "any".`);
            }
            return {operation, expression};
        }
    },
    subtract: {
        canNest: false,
        template: function subtract(options, attr, path, value) {
            let operation = "";
            let expression = "";
            switch(attr.type) {
                case AttributeTypes.any:
                case AttributeTypes.number:
                    operation = ItemOperations.set;
                    expression = `${path} = ${path} - ${value}`;
                    break;
                default:
                    throw new Error(`Invalid Update Attribute Operation: "SUBTRACT" Operation can only be performed on attributes with type "number" or "any".`);
            }

            return {operation, expression};
        }
    },
    set: {
        canNest: false,
        template: function set(options, attr, path, value) {
            let operation = "";
            let expression = "";
            switch(attr.type) {
                case AttributeTypes.set:
                case AttributeTypes.list:
                case AttributeTypes.map:
                case AttributeTypes.enum:
                case AttributeTypes.string:
                case AttributeTypes.number:
                case AttributeTypes.boolean:
                case AttributeTypes.any:
                    operation = ItemOperations.set;
                    expression = `${path} = ${value}`;
                    break;
                default:
                    throw new Error(`Invalid Update Attribute Operation: "SET" Operation can only be performed on attributes with type "list", "map", "string", "number", "boolean", or "any".`);
            }
            return {operation, expression};
        }
    },
    remove: {
        canNest: false,
        template: function remove(options, attr, ...paths) {
            let operation = "";
            let expression = "";
            switch(attr.type) {
                case AttributeTypes.set:
                case AttributeTypes.any:
                case AttributeTypes.list:
                case AttributeTypes.map:
                case AttributeTypes.string:
                case AttributeTypes.number:
                case AttributeTypes.boolean:
                case AttributeTypes.enum:
                    operation = ItemOperations.remove;
                    expression = paths.join(", ");
                    break;
                default: {
                    throw new Error(`Invalid Update Attribute Operation: "REMOVE" Operation can only be performed on attributes with type "map", "list", "string", "number", "boolean", or "any".`);
                }
            }
            return {operation, expression};
        }
    },
    del: deleteOperations,
    delete: deleteOperations
}

const FilterOperations = {
    ne: {
        template: function eq(options, attr, name, value) {
            return `${name} <> ${value}`;
        },
        strict: false,
    },
    eq: {
        template: function eq(options, attr, name, value) {
            return `${name} = ${value}`;
        },
        strict: false,
    },
    gt: {
        template: function gt(options, attr, name, value) {
            return `${name} > ${value}`;
        },
        strict: false
    },
    lt: {
        template: function lt(options, attr, name, value) {
            return `${name} < ${value}`;
        },
        strict: false
    },
    gte: {
        template: function gte(options, attr, name, value) {
            return `${name} >= ${value}`;
        },
        strict: false
    },
    lte: {
        template: function lte(options, attr, name, value) {
            return `${name} <= ${value}`;
        },
        strict: false
    },
    between: {
        template: function between(options, attr, name, value1, value2) {
            return `(${name} between ${value1} and ${value2})`;
        },
        strict: false
    },
    begins: {
        template: function begins(options, attr, name, value) {
            return `begins_with(${name}, ${value})`;
        },
        strict: false
    },
    exists: {
        template: function exists(options, attr, name) {
            return `attribute_exists(${name})`;
        },
        strict: false
    },
    notExists: {
        template: function notExists(options, attr, name) {
            return `attribute_not_exists(${name})`;
        },
        strict: false
    },
    contains: {
        template: function contains(options, attr, name, value) {
            return `contains(${name}, ${value})`;
        },
        strict: false
    },
    notContains: {
        template: function notContains(options, attr, name, value) {
            return `not contains(${name}, ${value})`;
        },
        strict: false
    },
    value: {
        template: function(options, attr, name, value) {
            return value;
        },
        strict: false,
        canNest: true,
    },
    name: {
        template: function(options, attr, name) {
            return name;
        },
        strict: false,
        canNest: true,
    }
};

class ExpressionState {
    constructor({prefix} = {}) {
        this.names = {};
        this.values = {};
        this.paths = {};
        this.counts = {};
        this.impacted = {};
        this.expression = "";
        this.prefix = prefix || "";
        this.refs = {};
    }

    incrementName(name) {
        if (this.counts[name] === undefined) {
            this.counts[name] = 0;
        }
        return `${this.prefix}${this.counts[name]++}`;
    }

    // todo: make the structure: name, value, paths
    setName(paths, name, value) {
        let json = "";
        let expression = "";
        const prop = `#${name}`;
        if (Object.keys(paths).length === 0) {
            json = `${name}`;
            expression = `${prop}`;
            this.names[prop] = value;
        } else if (isNaN(name)) {
            json = `${paths.json}.${name}`;
            expression = `${paths.expression}.${prop}`;
            this.names[prop] = value;
        } else {
            json = `${paths.json}[*]`;
            expression = `${paths.expression}[${name}]`;
        }
        return {json, expression, prop};
    }

    getNames() {
        return this.names;
    }

    setValue(name, value) {
        let valueCount = this.incrementName(name);
        let expression = `:${name}${valueCount}`
        this.values[expression] = value;
        return expression;
    }

    updateValue(name, value) {
        this.values[name] = value;
    }

    getValues() {
        return this.values;
    }

    setPath(path, value) {
        this.paths[path] = value;
    }

    setExpression(expression) {
        this.expression = expression;
    }

    getExpression() {
        return this.expression;
    }

    setImpacted(operation, path, ref) {
        this.impacted[path] = operation;
        this.refs[path] = ref;
    }
}

class AttributeOperationProxy {
    constructor({builder, attributes = {}, operations = {}}) {
        this.ref = {
            attributes,
            operations
        };
        this.attributes = AttributeOperationProxy.buildAttributes(builder, attributes);
        this.operations = AttributeOperationProxy.buildOperations(builder, operations);
    }

    invokeCallback(op, ...params) {
        return op(this.attributes, this.operations, ...params);
    }

    fromObject(operation, record) {
        for (let path of Object.keys(record)) {
            if (record[path] === undefined) {
                continue;
            }
            const value = record[path];
            const parts = u.parseJSONPath(path);
            let attribute = this.attributes;
            for (let part of parts) {
                attribute = attribute[part];
            }
            if (attribute) {
                this.operations[operation](attribute, value);
                const {target} = attribute();
                if (target.readOnly) {
                    throw new Error(`Attribute "${target.path}" is Read-Only and cannot be updated`);
                }
            }
        }
    }

    fromArray(operation, paths) {
        for (let path of paths) {
            const parts = u.parseJSONPath(path);
            let attribute = this.attributes;
            for (let part of parts) {
                attribute = attribute[part];
            }
            if (attribute) {
                this.operations[operation](attribute);
                const {target} = attribute();
                if (target.readOnly) {
                    throw new Error(`Attribute "${target.path}" is Read-Only and cannot be updated`);
                } else if (operation === ItemOperations.remove && target.required) {
                    throw new Error(`Attribute "${target.path}" is Required and cannot be removed`);
                }
            }
        }
    }

    static buildOperations(builder, operations) {
        let ops = {};
        let seen = new Set();
        for (let operation of Object.keys(operations)) {
            let {template, canNest} = operations[operation];
            Object.defineProperty(ops, operation, {
                get: () => {
                    return (property, ...values) => {
                        if (property === undefined) {
                            throw new e.ElectroError(e.ErrorCodes.InvalidWhere, `Invalid/Unknown property passed in where clause passed to operation: '${operation}'`);
                        }
                        if (property.__is_clause__ === AttributeProxySymbol) {
                            const {paths, root, target} = property();
                            const attributeValues = [];
                            let hasNestedValue = false;
                            for (let value of values) {
                                value = target.applyFixings(value);
                                // template.length is to see if function takes value argument
                                if (template.length > 3) {
                                    if (seen.has(value)) {
                                        attributeValues.push(value);
                                        hasNestedValue = true;
                                    } else {
                                        let attributeValueName = builder.setValue(target.name, value);
                                        builder.setPath(paths.json, {value, name: attributeValueName});
                                        attributeValues.push(attributeValueName);
                                    }
                                }
                            }

                            const options = {
                                nestedValue: hasNestedValue
                            }

                            const formatted = template(options, target, paths.expression, ...attributeValues);
                            builder.setImpacted(operation, paths.json, target);
                            if (canNest) {
                                seen.add(paths.expression);
                                seen.add(formatted);
                            }

                            if (builder.type === BuilderTypes.update && formatted && typeof formatted.operation === "string" && typeof formatted.expression === "string") {
                                builder.add(formatted.operation, formatted.expression);
                                return formatted.expression;
                            }

                            return formatted;
                        } else {
                            throw new e.ElectroError(e.ErrorCodes.InvalidWhere, `Invalid Attribute in where clause passed to operation '${operation}'. Use injected attributes only.`);
                        }
                    }
                }
            });
        }
        return ops;
    }

    static pathProxy(build) {
        return new Proxy(() => build(), {
            get: (_, prop, o) => {
                if (prop === "__is_clause__") {
                    return AttributeProxySymbol;
                } else {
                    return AttributeOperationProxy.pathProxy(() => {
                        const { paths, root, target, builder } = build();
                        const attribute = target.getChild(prop);
                        let field;
                        if (attribute === undefined) {
                            throw new Error(`Invalid attribute "${prop}" at path "${paths.json}".`);
                        } else if (attribute === root && attribute.type === AttributeTypes.any) {
                            // This function is only called if a nested property is called. If this attribute is ultimately the root, don't use the root's field name
                            field = prop;
                        } else {
                            field = attribute.field;
                        }

                        return {
                            root,
                            builder,
                            target: attribute,
                            paths: builder.setName(paths, prop, field),
                        }
                    });
                }
            }
        });
    }

    static buildAttributes(builder, attributes) {
        let attr = {};
        for (let [name, attribute] of Object.entries(attributes)) {
            Object.defineProperty(attr, name, {
                get: () => {
                    return AttributeOperationProxy.pathProxy(() => {
                        const paths = builder.setName({}, attribute.name, attribute.field);
                        return {
                            paths,
                            root: attribute,
                            target: attribute,
                            builder,
                        }
                    });
                }
            });
        }
        return attr;
    }
}

const FilterOperationNames = Object.keys(FilterOperations).reduce((ops, name) => {
    ops[name] = name;
    return ops;
}, {});

module.exports = {UpdateOperations, FilterOperations, FilterOperationNames, ExpressionState, AttributeOperationProxy};

1	const {AttributeTypes, ItemOperations, AttributeProxySymbol, BuilderTypes} = require("./types");	1✔
2	const e = require("./errors");	1✔
3	const u = require("./util");	1✔
4
5	const deleteOperations = {	1✔
6	canNest: false,
7	template: function del(options, attr, path, value) {
8	let operation = "";	24✔
9	let expression = "";	24✔
10	switch(attr.type) {	24!
11	case AttributeTypes.any:
12	case AttributeTypes.set:
13	operation = ItemOperations.delete;	22✔
14	expression = `${path} ${value}`;	22✔
15	break;	22✔
16	default:
17	throw new Error(`Invalid Update Attribute Operation: "DELETE" Operation can only be performed on attributes with type "set" or "any".`);	2✔
18	}
19	return {operation, expression};	22✔
20	},
21	};
22
23	const UpdateOperations = {	1✔
24	ifNotExists: {
25	template: function if_not_exists(options, attr, path, value) {
26	const operation = ItemOperations.set;	4✔
27	const expression = `${path} = if_not_exists(${path}, ${value})`;	4✔
28	return {operation, expression};	4✔
29	}
30	},
31	name: {
32	canNest: true,
33	template: function name(options, attr, path) {
34	return path;	9✔
35	}
36	},
37	value: {
38	canNest: true,
39	template: function value(options, attr, path, value) {
40	return value;	6✔
41	}
42	},
43	append: {
44	canNest: false,
45	template: function append(options, attr, path, value) {
46	let operation = "";	42✔
47	let expression = "";	42✔
48	switch(attr.type) {	42✔
49	case AttributeTypes.any:
50	case AttributeTypes.list:
51	operation = ItemOperations.set;	40✔
52	expression = `${path} = list_append(${path}, ${value})`;	40✔
53	break;	40✔
54	default:
55	throw new Error(`Invalid Update Attribute Operation: "APPEND" Operation can only be performed on attributes with type "list" or "any".`);	2✔
56	}
57	return {operation, expression};	40✔
58	}
59	},
60	add: {
61	canNest: false,
62	template: function add(options, attr, path, value) {
63	let operation = "";	78✔
64	let expression = "";	78✔
65	let type = attr.type;	78✔
66	if (type === AttributeTypes.any) {	78✔
67	type = typeof value === 'number'	1!
68	? AttributeTypes.number
69	: AttributeTypes.any;
70	}
71	switch(type) {	78✔
72	case AttributeTypes.any:
73	case AttributeTypes.set:
74	operation = ItemOperations.add;	46✔
75	expression = `${path} ${value}`;	46✔
76	break;	46✔
77	case AttributeTypes.number:
78	if (options.nestedValue) {	30✔
79	operation = ItemOperations.set;	9✔
80	expression = `${path} = ${path} + ${value}`;	9✔
81	} else {
82	operation = ItemOperations.add;	21✔
83	expression = `${path} ${value}`;	21✔
84	}
85	break;	30✔
86	default:
87	throw new Error(`Invalid Update Attribute Operation: "ADD" Operation can only be performed on attributes with type "number", "set", or "any".`);	2✔
88	}
89	return {operation, expression};	76✔
90	}
91	},
92	subtract: {
93	canNest: false,
94	template: function subtract(options, attr, path, value) {
95	let operation = "";	18✔
96	let expression = "";	18✔
97	switch(attr.type) {	18!
98	case AttributeTypes.any:
99	case AttributeTypes.number:
100	operation = ItemOperations.set;	18✔
101	expression = `${path} = ${path} - ${value}`;	18✔
102	break;	18✔
103	default:
104	throw new Error(`Invalid Update Attribute Operation: "SUBTRACT" Operation can only be performed on attributes with type "number" or "any".`);	×
105	}
106
107	return {operation, expression};	18✔
108	}
109	},
110	set: {
111	canNest: false,
112	template: function set(options, attr, path, value) {
113	let operation = "";	270✔
114	let expression = "";	270✔
115	switch(attr.type) {	270!
116	case AttributeTypes.set:
117	case AttributeTypes.list:
118	case AttributeTypes.map:
119	case AttributeTypes.enum:
120	case AttributeTypes.string:
121	case AttributeTypes.number:
122	case AttributeTypes.boolean:
123	case AttributeTypes.any:
124	operation = ItemOperations.set;	270✔
125	expression = `${path} = ${value}`;	270✔
126	break;	270✔
127	default:
128	throw new Error(`Invalid Update Attribute Operation: "SET" Operation can only be performed on attributes with type "list", "map", "string", "number", "boolean", or "any".`);	×
129	}
130	return {operation, expression};	270✔
131	}
132	},
133	remove: {
134	canNest: false,
135	template: function remove(options, attr, ...paths) {
136	let operation = "";	66✔
137	let expression = "";	66✔
138	switch(attr.type) {	66!
139	case AttributeTypes.set:
140	case AttributeTypes.any:
141	case AttributeTypes.list:
142	case AttributeTypes.map:
143	case AttributeTypes.string:
144	case AttributeTypes.number:
145	case AttributeTypes.boolean:
146	case AttributeTypes.enum:
147	operation = ItemOperations.remove;	66✔
148	expression = paths.join(", ");	66✔
149	break;	66✔
150	default: {
151	throw new Error(`Invalid Update Attribute Operation: "REMOVE" Operation can only be performed on attributes with type "map", "list", "string", "number", "boolean", or "any".`);	×
152	}
153	}
154	return {operation, expression};	66✔
155	}
156	},
157	del: deleteOperations,
158	delete: deleteOperations
159	}
160
161	const FilterOperations = {	1✔
162	ne: {
163	template: function eq(options, attr, name, value) {
164	return `${name} <> ${value}`;	×
165	},
166	strict: false,
167	},
168	eq: {
169	template: function eq(options, attr, name, value) {
170	return `${name} = ${value}`;	451✔
171	},
172	strict: false,
173	},
174	gt: {
175	template: function gt(options, attr, name, value) {
176	return `${name} > ${value}`;	43✔
177	},
178	strict: false
179	},
180	lt: {
181	template: function lt(options, attr, name, value) {
182	return `${name} < ${value}`;	3✔
183	},
184	strict: false
185	},
186	gte: {
187	template: function gte(options, attr, name, value) {
188	return `${name} >= ${value}`;	10✔
189	},
190	strict: false
191	},
192	lte: {
193	template: function lte(options, attr, name, value) {
194	return `${name} <= ${value}`;	74✔
195	},
196	strict: false
197	},
198	between: {
199	template: function between(options, attr, name, value1, value2) {
200	return `(${name} between ${value1} and ${value2})`;	8✔
201	},
202	strict: false
203	},
204	begins: {
205	template: function begins(options, attr, name, value) {
206	return `begins_with(${name}, ${value})`;	3✔
207	},
208	strict: false
209	},
210	exists: {
211	template: function exists(options, attr, name) {
212	return `attribute_exists(${name})`;	177✔
213	},
214	strict: false
215	},
216	notExists: {
217	template: function notExists(options, attr, name) {
218	return `attribute_not_exists(${name})`;	188✔
219	},
220	strict: false
221	},
222	contains: {
223	template: function contains(options, attr, name, value) {
224	return `contains(${name}, ${value})`;	9✔
225	},
226	strict: false
227	},
228	notContains: {
229	template: function notContains(options, attr, name, value) {
230	return `not contains(${name}, ${value})`;	9✔
231	},
232	strict: false
233	},
234	value: {
235	template: function(options, attr, name, value) {
236	return value;	10✔
237	},
238	strict: false,
239	canNest: true,
240	},
241	name: {
242	template: function(options, attr, name) {
243	return name;	9✔
244	},
245	strict: false,
246	canNest: true,
247	}
248	};
249
250	class ExpressionState {
251	constructor({prefix} = {}) {	20,064✔
252	this.names = {};	30,096✔
253	this.values = {};	30,096✔
254	this.paths = {};	30,096✔
255	this.counts = {};	30,096✔
256	this.impacted = {};	30,096✔
257	this.expression = "";	30,096✔
258	this.prefix = prefix \|\| "";	30,096✔
259	this.refs = {};	30,096✔
260	}
261
262	incrementName(name) {
263	if (this.counts[name] === undefined) {	2,332✔
264	this.counts[name] = 0;	2,313✔
265	}
266	return `${this.prefix}${this.counts[name]++}`;	2,332✔
267	}
268
269	// todo: make the structure: name, value, paths
270	setName(paths, name, value) {
271	let json = "";	3,282✔
272	let expression = "";	3,282✔
273	const prop = `#${name}`;	3,282✔
274	if (Object.keys(paths).length === 0) {	3,282✔
275	json = `${name}`;	3,183✔
276	expression = `${prop}`;	3,183✔
277	this.names[prop] = value;	3,183✔
278	} else if (isNaN(name)) {	99✔
279	json = `${paths.json}.${name}`;	64✔
280	expression = `${paths.expression}.${prop}`;	64✔
281	this.names[prop] = value;	64✔
282	} else {
283	json = `${paths.json}[*]`;	35✔
284	expression = `${paths.expression}[${name}]`;	35✔
285	}
286	return {json, expression, prop};	3,282✔
287	}
288
289	getNames() {
290	return this.names;	1,637✔
291	}
292
293	setValue(name, value) {
294	let valueCount = this.incrementName(name);	2,332✔
295	let expression = `:${name}${valueCount}`	2,332✔
296	this.values[expression] = value;	2,332✔
297	return expression;	2,332✔
298	}
299
300	updateValue(name, value) {
301	this.values[name] = value;	381✔
302	}
303
304	getValues() {
305	return this.values;	1,459✔
306	}
307
308	setPath(path, value) {
309	this.paths[path] = value;	521✔
310	}
311
312	setExpression(expression) {
313	this.expression = expression;	×
314	}
315
316	getExpression() {
317	return this.expression;	2✔
318	}
319
320	setImpacted(operation, path, ref) {
321	this.impacted[path] = operation;	633✔
322	this.refs[path] = ref;	633✔
323	}
324	}
325
326	class AttributeOperationProxy {
327	constructor({builder, attributes = {}, operations = {}}) {	×
328	this.ref = {	10,145✔
329	attributes,
330	operations
331	};
332	this.attributes = AttributeOperationProxy.buildAttributes(builder, attributes);	10,145✔
333	this.operations = AttributeOperationProxy.buildOperations(builder, operations);	10,145✔
334	}
335
336	invokeCallback(op, ...params) {
337	return op(this.attributes, this.operations, ...params);	163✔
338	}
339
340	fromObject(operation, record) {
341	for (let path of Object.keys(record)) {	290✔
342	if (record[path] === undefined) {	346!
343	continue;	×
344	}
345	const value = record[path];	346✔
346	const parts = u.parseJSONPath(path);	346✔
347	let attribute = this.attributes;	346✔
348	for (let part of parts) {	346✔
349	attribute = attribute[part];	354✔
350	}
351	if (attribute) {	346!
352	this.operations[operation](attribute, value);	346✔
353	const {target} = attribute();	340✔
354	if (target.readOnly) {	340✔
355	throw new Error(`Attribute "${target.path}" is Read-Only and cannot be updated`);	1✔
356	}
357	}
358	}
359	}
360
361	fromArray(operation, paths) {
362	for (let path of paths) {	25✔
363	const parts = u.parseJSONPath(path);	40✔
364	let attribute = this.attributes;	40✔
365	for (let part of parts) {	40✔
366	attribute = attribute[part];	42✔
367	}
368	if (attribute) {	40!
369	this.operations[operation](attribute);	40✔
370	const {target} = attribute();	40✔
371	if (target.readOnly) {	40!
372	throw new Error(`Attribute "${target.path}" is Read-Only and cannot be updated`);	×
373	} else if (operation === ItemOperations.remove && target.required) {	40!
374	throw new Error(`Attribute "${target.path}" is Required and cannot be removed`);	×
375	}
376	}
377	}
378	}
379
380	static buildOperations(builder, operations) {
381	let ops = {};	10,145✔
382	let seen = new Set();	10,145✔
383	for (let operation of Object.keys(operations)) {	10,145✔
384	let {template, canNest} = operations[operation];	101,902✔
385	Object.defineProperty(ops, operation, {	101,902✔
386	get: () => {
387	return (property, ...values) => {	628✔
388	if (property === undefined) {	642✔
389	throw new e.ElectroError(e.ErrorCodes.InvalidWhere, `Invalid/Unknown property passed in where clause passed to operation: '${operation}'`);	2✔
390	}
391	if (property.__is_clause__ === AttributeProxySymbol) {	640✔
392	const {paths, root, target} = property();	639✔
393	const attributeValues = [];	639✔
394	let hasNestedValue = false;	639✔
395	for (let value of values) {	639✔
396	value = target.applyFixings(value);	543✔
397	// template.length is to see if function takes value argument
398	if (template.length > 3) {	543!
399	if (seen.has(value)) {	543✔
400	attributeValues.push(value);	22✔
401	hasNestedValue = true;	22✔
402	} else {
403	let attributeValueName = builder.setValue(target.name, value);	521✔
404	builder.setPath(paths.json, {value, name: attributeValueName});	521✔
405	attributeValues.push(attributeValueName);	521✔
406	}
407	}
408	}
409
410	const options = {	639✔
411	nestedValue: hasNestedValue
412	}
413
414	const formatted = template(options, target, paths.expression, ...attributeValues);	639✔
415	builder.setImpacted(operation, paths.json, target);	633✔
416	if (canNest) {	633✔
417	seen.add(paths.expression);	32✔
418	seen.add(formatted);	32✔
419	}
420
421	if (builder.type === BuilderTypes.update && formatted && typeof formatted.operation === "string" && typeof formatted.expression === "string") {	633✔
422	builder.add(formatted.operation, formatted.expression);	496✔
423	return formatted.expression;	496✔
424	}
425
426	return formatted;	137✔
427	} else {
428	throw new e.ElectroError(e.ErrorCodes.InvalidWhere, `Invalid Attribute in where clause passed to operation '${operation}'. Use injected attributes only.`);	1✔
429	}
430	}
431	}
432	});
433	}
434	return ops;	10,145✔
435	}
436
437	static pathProxy(build) {
438	return new Proxy(() => build(), {	1,019✔
439	get: (_, prop, o) => {
440	if (prop === "__is_clause__") {	727✔
441	return AttributeProxySymbol;	639✔
442	} else {
443	return AttributeOperationProxy.pathProxy(() => {	88✔
444	const { paths, root, target, builder } = build();	99✔
445	const attribute = target.getChild(prop);	99✔
446	let field;
447	if (attribute === undefined) {	99!
448	throw new Error(`Invalid attribute "${prop}" at path "${paths.json}".`);	×
449	} else if (attribute === root && attribute.type === AttributeTypes.any) {	99✔
450	// This function is only called if a nested property is called. If this attribute is ultimately the root, don't use the root's field name
451	field = prop;	11✔
452	} else {
453	field = attribute.field;	88✔
454	}
455
456	return {	99✔
457	root,
458	builder,
459	target: attribute,
460	paths: builder.setName(paths, prop, field),
461	}
462	});
463	}
464	}
465	});
466	}
467
468	static buildAttributes(builder, attributes) {
469	let attr = {};	10,145✔
470	for (let [name, attribute] of Object.entries(attributes)) {	10,145✔
471	Object.defineProperty(attr, name, {	69,162✔
472	get: () => {
473	return AttributeOperationProxy.pathProxy(() => {	626✔
474	const paths = builder.setName({}, attribute.name, attribute.field);	1,019✔
475	return {	1,019✔
476	paths,
477	root: attribute,
478	target: attribute,
479	builder,
480	}
481	});
482	}
483	});
484	}
485	return attr;	10,145✔
486	}
487	}
488
489	const FilterOperationNames = Object.keys(FilterOperations).reduce((ops, name) => {	1✔
490	ops[name] = name;	14✔
491	return ops;	14✔
492	}, {});
493
494	module.exports = {UpdateOperations, FilterOperations, FilterOperationNames, ExpressionState, AttributeOperationProxy};	1✔

tywalch / electrodb / 381

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous