@deterministic-code/datasources 0.1.15 → 0.1.16

package/dist/Datasource.js

@@ -4,6 +4,7 @@ import { ReadonlyRepository } from "./ReadonlyRepository.js";
 import { RepositoryFactory } from "./RepositoryFactory.js";
 import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
 import { RowTypeConverter } from "./converters/RowTypeConverter.js";
+import { Schema } from "./Schema.js";
 import { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
 import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
 export class Datasource {
@@ -41,10 +42,12 @@ export class Datasource {
     applyCrud = (type, options) => {
         const built = createCRUDRepositoryOptions(type, this.driver.rowTypeConverters);
         const types = this.driver.rowTypeConverters;
-        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, columnsOf(type));
+        const schema = options?.schema ?? new Schema({});
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, schema.columns);
         return {
             ...(options ?? built),
             entity: options?.entity ?? built.entity,
+            schema,
             rowConverter: rows,
             rowTypeConverters: types,
             type,
@@ -53,10 +56,12 @@ export class Datasource {
     applyReadonly = (type, options) => {
         const built = createReadonlyRepositoryMappingOptions(type, this.driver.rowTypeConverters);
         const types = this.driver.rowTypeConverters;
-        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, columnsOf(type));
+        const schema = options?.schema ?? new Schema({});
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, schema.columns);
         return {
             ...(options ?? built),
             entity: options?.entity ?? built.entity,
+            schema,
             rowConverter: rows,
             rowTypeConverters: types,
             type,
@@ -77,22 +82,3 @@ export class Datasource {
         return Datasource.create();
     }
 }
-const columnsOf = (type) => {
-    const instance = new type();
-    const columns = {};
-    for (const [name, value] of Object.entries(instance)) {
-        if (Array.isArray(value))
-            continue;
-        const canonical = canonicalOf(value);
-        if (canonical)
-            columns[name] = canonical;
-    }
-    return columns;
-};
-const canonicalOf = (value) => typeof value === "boolean"
-    ? "bool"
-    : value instanceof Date
-        ? "datetime"
-        : value instanceof Uint8Array
-            ? "binary"
-            : undefined;

package/dist/IReadonlyRepository.d.ts

@@ -6,6 +6,7 @@ import type { IWhere } from "./statements/IWhere.js";
 import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
 export type ReadQuery = ISelectStatement | IWhere | IExecuteStoredProcedureStatement;
 export interface IReadonlyRepository<T = unknown> extends IRepository<T> {
+    readonly isSchemaRequired: boolean;
     readSingle(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): Promise<T | undefined>;
     read(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
 }

package/dist/ReadonlyRepository.d.ts

@@ -23,6 +23,7 @@ export declare const isBuilt: <T>(value: IConnection | BuiltRepository<T>) => va
 export declare const builtOf: <T>(typeOrConnectionOrBuilt: Constructable<T> | IConnection | BuiltRepository<T>, connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>) => BuiltRepository<T> | undefined;
 export declare class ReadonlyRepository<T> implements IReadonlyRepository<T>, IEnriched<T> {
     readonly type: Constructable<T>;
+    readonly isSchemaRequired = false;
     private connection?;
     protected rowConverter?: TypeConverter<Cells, Cells>;
     protected objectConverter?: TypeConverter<T, Cells>;

package/dist/ReadonlyRepository.js

@@ -22,6 +22,7 @@ export const builtOf = (typeOrConnectionOrBuilt, connectionOrOptions) => typeof
         : new ReadonlyRepositoryBuilder().parts(typeOrConnectionOrBuilt, connectionOrOptions);
 export class ReadonlyRepository {
     type;
+    isSchemaRequired = false;
     connection;
     rowConverter;
     objectConverter;

package/dist/ReadonlyRepositoryMappingOptions.d.ts

@@ -2,6 +2,7 @@ import type { Cell, Cells } from "./converters/Cell.js";
 import type { Constructable } from "./converters/Constructable.js";
 import type { TypeConverter } from "./converters/TypeConverter.js";
 import type { IMapper } from "./mappers/IMapper.js";
+import type { Schema } from "./Schema.js";
 export type ReadonlyRepositoryMappingOptions<T = Cells> = {
     entity?: string;
     entityMapper?: IMapper<string, string>;
@@ -11,4 +12,5 @@ export type ReadonlyRepositoryMappingOptions<T = Cells> = {
     type?: Constructable<T>;
     rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>;
     readProperties?: string[];
+    schema?: Schema;
 };

package/dist/Schema.d.ts

@@ -0,0 +1,4 @@
+export declare class Schema {
+    readonly columns: Readonly<Record<string, string>>;
+    constructor(columns: Readonly<Record<string, string>>);
+}

package/dist/Schema.js

@@ -0,0 +1,6 @@
+export class Schema {
+    columns;
+    constructor(columns) {
+        this.columns = columns;
+    }
+}

package/dist/index.d.ts

@@ -118,6 +118,8 @@ export type { TypeMapGroup } from "./mappers/TypeMapGroup.js";
 export { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.js";
 export { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.js";
 export { DictionaryMapper } from "./mappers/DictionaryMapper.js";
+export { DeterministicTypeMapper } from "./mappers/DeterministicTypeMapper.js";
+export { Schema } from "./Schema.js";
 export { IdentityMapper } from "./mappers/IdentityMapper.js";
 export { PluralizerMapper } from "./mappers/PluralizerMapper.js";
 export { TransformMapper } from "./mappers/TransformMapper.js";

package/dist/index.js

@@ -72,6 +72,8 @@ export { ReplaceConverter } from "./converters/ReplaceConverter.js";
 export { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.js";
 export { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.js";
 export { DictionaryMapper } from "./mappers/DictionaryMapper.js";
+export { DeterministicTypeMapper } from "./mappers/DeterministicTypeMapper.js";
+export { Schema } from "./Schema.js";
 export { IdentityMapper } from "./mappers/IdentityMapper.js";
 export { PluralizerMapper } from "./mappers/PluralizerMapper.js";
 export { TransformMapper } from "./mappers/TransformMapper.js";

package/dist/mappers/DeterministicTypeMapper.d.ts

@@ -0,0 +1,5 @@
+import type { IMapper } from "./IMapper.js";
+export declare class DeterministicTypeMapper implements IMapper<string, string> {
+    map: (value: string) => string;
+    reverseMap: (value: string) => string;
+}

package/dist/mappers/DeterministicTypeMapper.js

@@ -0,0 +1,21 @@
+const forward = {
+    boolean: "boolean",
+    Boolean: "boolean",
+    number: "integer",
+    Number: "integer",
+    bigint: "biginteger",
+    BigInt: "biginteger",
+    Date: "datetime",
+    Uint8Array: "binary",
+};
+const reverse = {
+    boolean: "boolean",
+    integer: "number",
+    biginteger: "bigint",
+    datetime: "Date",
+    binary: "Uint8Array",
+};
+export class DeterministicTypeMapper {
+    map = (value) => forward[value] ?? "";
+    reverseMap = (value) => reverse[value] ?? "";
+}

package/dist/statements/ArrayExpression.js

@@ -1,6 +1,8 @@
+import { brand } from "./brand.js";
 export class ArrayExpression {
     elements;
     constructor(elements) {
         this.elements = elements;
     }
 }
+brand(ArrayExpression);

package/dist/statements/ConditionRenderer.js

@@ -1,4 +1,6 @@
+import { is } from "./brand.js";
 import { Where } from "./Where.js";
+import { WhereText } from "./WhereText.js";
 export class ConditionRenderer {
     expressions;
     constructor(expressions) {
@@ -6,8 +8,12 @@ export class ConditionRenderer {
     }
     render = (condition) => condition.accept(this);
     visit(where) {
-        return where instanceof Where || where.constructor.name === "Where"
+        return is(where, Where)
             ? this.expressions.render(where.condition)
-            : where.rawText;
+            : is(where, WhereText)
+                ? where.rawText
+                : (() => {
+                    throw new Error("empty expression");
+                })();
     }
 }

package/dist/statements/ExpressionRenderer.js

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

package/dist/statements/Identifier.js

@@ -1,6 +1,8 @@
+import { brand } from "./brand.js";
 export class Identifier {
     name;
     constructor(name) {
         this.name = name;
     }
 }
+brand(Identifier);

package/dist/statements/Literal.js

@@ -1,6 +1,8 @@
+import { brand } from "./brand.js";
 export class Literal {
     value;
     constructor(value) {
         this.value = value;
     }
 }
+brand(Literal);

package/dist/statements/Operator.js

@@ -2,6 +2,7 @@ import { ArrayExpression } from "./ArrayExpression.js";
 import { Condition } from "./Condition.js";
 import { Identifier } from "./Identifier.js";
 import { Literal } from "./Literal.js";
+import { brand } from "./brand.js";
 const pair = (left, right) => typeof left === "string"
     ? [new Identifier(left), new Literal(right)]
     : [left, right];
@@ -205,3 +206,21 @@ export class Operator extends Condition {
     }
     Operator.Exists = Exists;
 })(Operator || (Operator = {}));
+brand(Operator.Equals);
+brand(Operator.NotEquals);
+brand(Operator.GreaterThan);
+brand(Operator.LessThan);
+brand(Operator.GreaterThanOrEqual);
+brand(Operator.LessThanOrEqual);
+brand(Operator.And);
+brand(Operator.Or);
+brand(Operator.In);
+brand(Operator.Not);
+brand(Operator.IsNull);
+brand(Operator.IsNotNull);
+brand(Operator.Like);
+brand(Operator.NotLike);
+brand(Operator.Between);
+brand(Operator.NotBetween);
+brand(Operator.NotIn);
+brand(Operator.Exists);

package/dist/statements/StatementTextRenderer.js

@@ -1,3 +1,4 @@
+import { is } from "./brand.js";
 import { ConditionRenderer } from "./ConditionRenderer.js";
 import { ExpressionRenderer } from "./ExpressionRenderer.js";
 import { StatementRenderer } from "./StatementRenderer.js";
@@ -12,16 +13,8 @@ export class StatementTextRenderer {
         this.conditions = conditions?.(expressionRenderer) ?? new ConditionRenderer(expressionRenderer);
     }
     render(target) {
-        if (target.constructor.name === "Where" || target.constructor.name === "WhereText") {
-            return target.accept(this.conditions);
-        }
-        if (target.constructor.name.endsWith("Statement")) {
-            return target.accept(this.statements);
-        }
-        if (target instanceof Where || target instanceof WhereText)
-            return target.accept(this.conditions);
-        return "where" in target || "fields" in target || "joins" in target || "column" in target
-            ? target.accept(this.statements)
-            : target.accept(this.conditions);
+        return is(target, Where) || is(target, WhereText)
+            ? target.accept(this.conditions)
+            : target.accept(this.statements);
     }
 }

package/dist/statements/Subquery.js

@@ -1,6 +1,8 @@
+import { brand } from "./brand.js";
 export class Subquery {
     query;
     constructor(query) {
         this.query = query;
     }
 }
+brand(Subquery);

package/dist/statements/Where.js

@@ -5,6 +5,7 @@ import { Operator } from "./Operator.js";
 import { eq } from "./Cmp.js";
 import { SelectStatement } from "./SelectStatement.js";
 import { Subquery } from "./Subquery.js";
+import { brand } from "./brand.js";
 const pair = (expression) => expression instanceof Operator.Equals ||
     expression instanceof Operator.NotEquals ||
     expression instanceof Operator.GreaterThan ||
@@ -181,3 +182,4 @@ export class Where {
         return collect(this.condition);
     }
 }
+brand(Where);

package/dist/statements/WhereText.js

@@ -1,3 +1,4 @@
+import { brand } from "./brand.js";
 export class WhereText {
     text;
     constructor(text) {
@@ -8,3 +9,4 @@ export class WhereText {
     }
     accept = (visitor) => visitor.visit(this);
 }
+brand(WhereText);

package/dist/statements/brand.d.ts

@@ -0,0 +1,5 @@
+export declare const brand: (type: {
+    name: string;
+    prototype: object;
+}) => void;
+export declare const is: <T extends object>(value: object, type: abstract new (...args: never[]) => T) => value is T;

package/dist/statements/brand.js

@@ -0,0 +1,5 @@
+const key = (name) => Symbol.for(`@deterministic-code/datasources/${name}`);
+export const brand = (type) => {
+    Object.defineProperty(type.prototype, key(type.name), { value: true });
+};
+export const is = (value, type) => value instanceof type || Boolean(value[key(type.name)]);

package/package.json

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