@deterministic-code/datasources 0.1.14 → 0.1.15

package/dist/BatchCommandIBulkWriteStrategy.js

@@ -83,7 +83,7 @@ export class BatchCommandIBulkWriteStrategy {
         return { result: null, rowsAffected };
     };
     mappedInsert = (item) => {
-        const record = this.reverse(item);
+        const record = this.repo.fillCreateZeros(this.reverse(item));
         const statement = this.statements().insert(this.fields(record, (col) => listed(this.options.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null))));
         return { table: statement.table, fields: statement.fields };
     };

package/dist/CRUDRepository.d.ts

@@ -14,6 +14,7 @@ export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> imp
     readonly ids: readonly string[];
     private readonly createProperties?;
     private readonly updateProperties?;
+    protected createZeros?: Cells;
     private readonly crudStatements;
     private readonly tree;
     private readonly write;
@@ -36,6 +37,7 @@ export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> imp
     private save;
     private remove;
     private byId;
+    fillCreateZeros: (record: Cells) => Cells;
     private reverseConvert;
     private idWhere;
     protected enrichmentInto: (name: string) => boolean;

package/dist/CRUDRepository.js

@@ -37,6 +37,7 @@ export class CRUDRepository extends ReadonlyRepository {
     ids;
     createProperties;
     updateProperties;
+    createZeros;
     crudStatements;
     tree;
     write;
@@ -118,7 +119,7 @@ export class CRUDRepository extends ReadonlyRepository {
     readSingleById = async (id) => this.readSingle(this.byId(id));
     insert = async (item) => {
         const extras = lookupKeys(item);
-        const record = this.reverseConvert(item);
+        const record = this.fillCreateZeros(this.reverseConvert(item));
         const fields = fieldsOf(record, (col) => extras.has(col) || listed(this.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null)), extras, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
         const statement = this.crudStatements.insert(fields);
         const response = await execute(this.command(), statement, statement.fields);
@@ -181,6 +182,7 @@ export class CRUDRepository extends ReadonlyRepository {
             throw new DatasourceError("Composite id requires a row keyed by each Id column");
         return this.idWhere({ [this.ids[0]]: id });
     };
+    fillCreateZeros = (record) => this.createZeros === undefined ? record : { ...this.createZeros, ...record };
     reverseConvert = (item) => {
         const row = this.objectConverter.reverseConvert(item);
         const converted = this.rowConverter ? this.rowConverter.reverseConvert(row) : row;

package/dist/statements/ConditionRenderer.js

@@ -6,6 +6,8 @@ export class ConditionRenderer {
     }
     render = (condition) => condition.accept(this);
     visit(where) {
-        return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
+        return where instanceof Where || where.constructor.name === "Where"
+            ? this.expressions.render(where.condition)
+            : where.rawText;
     }
 }

package/dist/statements/ExpressionRenderer.js

@@ -4,69 +4,70 @@ import { Literal } from "./Literal.js";
 import { Operator } from "./Operator.js";
 import { Subquery } from "./Subquery.js";
 import { Where } from "./Where.js";
+const is = (value, type, name) => value instanceof type || value.constructor.name === name;
 export class ExpressionRenderer {
     text;
     constructor(text) {
         this.text = text;
     }
     render = (expression) => {
-        if (expression instanceof Where)
+        if (is(expression, Where, "Where"))
             return this.render(expression.condition);
-        if (expression instanceof Identifier)
+        if (is(expression, Identifier, "Identifier"))
             return expression.name;
-        if (expression instanceof Literal)
+        if (is(expression, Literal, "Literal"))
             return inline(expression.value);
-        if (expression instanceof ArrayExpression)
+        if (is(expression, ArrayExpression, "ArrayExpression"))
             return expression.elements.map((e) => this.render(e)).join(", ");
-        if (expression instanceof Operator.Not)
+        if (is(expression, Operator.Not, "Not"))
             return `NOT (${this.render(expression.argument)})`;
-        if (expression instanceof Operator.IsNull)
+        if (is(expression, Operator.IsNull, "IsNull"))
             return `${this.render(expression.argument)} IS NULL`;
-        if (expression instanceof Operator.IsNotNull)
+        if (is(expression, Operator.IsNotNull, "IsNotNull"))
             return `${this.render(expression.argument)} IS NOT NULL`;
-        if (expression instanceof Operator.Exists)
+        if (is(expression, Operator.Exists, "Exists"))
             return `EXISTS ${this.render(expression.argument)}`;
-        if (expression instanceof Subquery)
+        if (is(expression, Subquery, "Subquery"))
             return `(${this.text.render(expression.query)})`;
-        if (expression instanceof Operator.In &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof ArrayExpression)
+        if (is(expression, Operator.In, "In") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, ArrayExpression, "ArrayExpression"))
             return expression.right.elements.length === 0
                 ? "1 = 0"
                 : `${expression.left.name} IN (${slots(expression.left.name, expression.right.elements.length)})`;
-        if (expression instanceof Operator.In &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof Subquery)
+        if (is(expression, Operator.In, "In") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, Subquery, "Subquery"))
             return `${expression.left.name} IN ${this.render(expression.right)}`;
-        if (expression instanceof Operator.NotIn &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof ArrayExpression)
+        if (is(expression, Operator.NotIn, "NotIn") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, ArrayExpression, "ArrayExpression"))
             return expression.right.elements.length === 0
                 ? "1 = 1"
                 : `${expression.left.name} NOT IN (${slots(expression.left.name, expression.right.elements.length)})`;
-        if (expression instanceof Operator.NotIn &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof Subquery)
+        if (is(expression, Operator.NotIn, "NotIn") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, Subquery, "Subquery"))
             return `${expression.left.name} NOT IN ${this.render(expression.right)}`;
-        if ((expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
-            expression.value instanceof Identifier &&
-            expression.low instanceof Literal &&
-            expression.high instanceof Literal) {
-            const word = expression instanceof Operator.NotBetween ? "NOT BETWEEN" : "BETWEEN";
+        if ((is(expression, Operator.Between, "Between") || is(expression, Operator.NotBetween, "NotBetween")) &&
+            is(expression.value, Identifier, "Identifier") &&
+            is(expression.low, Literal, "Literal") &&
+            is(expression.high, Literal, "Literal")) {
+            const word = is(expression, Operator.NotBetween, "NotBetween") ? "NOT BETWEEN" : "BETWEEN";
             return `${expression.value.name} ${word} $${parameterName(expression.value.name)}_0 AND $${parameterName(expression.value.name)}_1`;
         }
-        if (expression instanceof Operator.Between)
+        if (is(expression, Operator.Between, "Between"))
             return `${this.render(expression.value)} BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
-        if (expression instanceof Operator.NotBetween)
+        if (is(expression, Operator.NotBetween, "NotBetween"))
             return `${this.render(expression.value)} NOT BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
-        if (expression instanceof Operator.And)
+        if (is(expression, Operator.And, "And"))
             return `${this.wrap(expression.left, true)} AND ${this.wrap(expression.right, true)}`;
-        if (expression instanceof Operator.Or)
+        if (is(expression, Operator.Or, "Or"))
             return `${this.wrap(expression.left, false)} OR ${this.wrap(expression.right, false)}`;
-        const operands = expression instanceof Operator ? pair(expression) : undefined;
-        if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
+        const operands = pair(expression);
+        if (operands && is(operands.left, Identifier, "Identifier") && is(operands.right, Literal, "Literal"))
             return `${operands.left.name} ${symbol(expression)} $${parameterName(operands.left.name)}`;
-        if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
+        if (operands && is(operands.left, Literal, "Literal") && is(operands.right, Literal, "Literal"))
             return `${inline(operands.left.value)} ${symbol(expression)} ${inline(operands.right.value)}`;
         if (operands)
             return `${this.render(operands.left)} ${symbol(expression)} ${this.render(operands.right)}`;
@@ -74,23 +75,34 @@ export class ExpressionRenderer {
     };
     wrap = (child, and) => needsParens(child, and) ? `(${this.render(child)})` : this.render(child);
 }
-const symbol = (op) => op instanceof Operator.Equals
-    ? "="
-    : op instanceof Operator.NotEquals
-        ? "<>"
-        : op instanceof Operator.GreaterThan
-            ? ">"
-            : op instanceof Operator.LessThan
-                ? "<"
-                : op instanceof Operator.GreaterThanOrEqual
-                    ? ">="
-                    : op instanceof Operator.LessThanOrEqual
-                        ? "<="
-                        : op instanceof Operator.Like
-                            ? "LIKE"
-                            : op instanceof Operator.NotLike
-                                ? "NOT LIKE"
-                                : "IN";
+const symbols = {
+    Equals: "=",
+    NotEquals: "<>",
+    GreaterThan: ">",
+    LessThan: "<",
+    GreaterThanOrEqual: ">=",
+    LessThanOrEqual: "<=",
+    Like: "LIKE",
+    NotLike: "NOT LIKE",
+};
+const symbol = (op) => symbols[op.constructor.name] ??
+    (is(op, Operator.Equals, "Equals")
+        ? "="
+        : is(op, Operator.NotEquals, "NotEquals")
+            ? "<>"
+            : is(op, Operator.GreaterThan, "GreaterThan")
+                ? ">"
+                : is(op, Operator.LessThan, "LessThan")
+                    ? "<"
+                    : is(op, Operator.GreaterThanOrEqual, "GreaterThanOrEqual")
+                        ? ">="
+                        : is(op, Operator.LessThanOrEqual, "LessThanOrEqual")
+                            ? "<="
+                            : is(op, Operator.Like, "Like")
+                                ? "LIKE"
+                                : is(op, Operator.NotLike, "NotLike")
+                                    ? "NOT LIKE"
+                                    : "IN");
 const inline = (value) => value === null
     ? "null"
     : typeof value === "boolean"
@@ -98,24 +110,24 @@ const inline = (value) => value === null
         : typeof value === "string"
             ? `'${value.replace(/'/g, "''")}'`
             : String(value);
-const needsParens = (child, and) => child instanceof Where
+const needsParens = (child, and) => is(child, Where, "Where")
     ? needsParens(child.condition, and)
-    : child instanceof Operator.Not ||
-        child instanceof Operator.In ||
-        child instanceof Operator.NotIn ||
-        (child instanceof Operator.And && !and) ||
-        (child instanceof Operator.Or && and);
-const pair = (expression) => expression instanceof Operator.Equals ||
-    expression instanceof Operator.NotEquals ||
-    expression instanceof Operator.GreaterThan ||
-    expression instanceof Operator.LessThan ||
-    expression instanceof Operator.GreaterThanOrEqual ||
-    expression instanceof Operator.LessThanOrEqual ||
-    expression instanceof Operator.And ||
-    expression instanceof Operator.Or ||
-    expression instanceof Operator.In ||
-    expression instanceof Operator.Like ||
-    expression instanceof Operator.NotLike
+    : is(child, Operator.Not, "Not") ||
+        is(child, Operator.In, "In") ||
+        is(child, Operator.NotIn, "NotIn") ||
+        (is(child, Operator.And, "And") && !and) ||
+        (is(child, Operator.Or, "Or") && and);
+const pair = (expression) => is(expression, Operator.Equals, "Equals") ||
+    is(expression, Operator.NotEquals, "NotEquals") ||
+    is(expression, Operator.GreaterThan, "GreaterThan") ||
+    is(expression, Operator.LessThan, "LessThan") ||
+    is(expression, Operator.GreaterThanOrEqual, "GreaterThanOrEqual") ||
+    is(expression, Operator.LessThanOrEqual, "LessThanOrEqual") ||
+    is(expression, Operator.And, "And") ||
+    is(expression, Operator.Or, "Or") ||
+    is(expression, Operator.In, "In") ||
+    is(expression, Operator.Like, "Like") ||
+    is(expression, Operator.NotLike, "NotLike")
     ? expression
     : undefined;
 const parameterName = (name) => parts(name)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",