@deterministic-code/datasources 0.1.14 → 0.1.16

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/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,6 +8,12 @@ export class ConditionRenderer {
     }
     render = (condition) => condition.accept(this);
     visit(where) {
-        return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
+        return is(where, Where)
+            ? this.expressions.render(where.condition)
+            : is(where, WhereText)
+                ? where.rawText
+                : (() => {
+                    throw new Error("empty expression");
+                })();
     }
 }

package/dist/statements/ExpressionRenderer.js

@@ -1,4 +1,5 @@
 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";
@@ -10,63 +11,55 @@ export class ExpressionRenderer {
         this.text = text;
     }
     render = (expression) => {
-        if (expression instanceof Where)
+        if (is(expression, Where))
             return this.render(expression.condition);
-        if (expression instanceof Identifier)
+        if (is(expression, Identifier))
             return expression.name;
-        if (expression instanceof Literal)
+        if (is(expression, Literal))
             return inline(expression.value);
-        if (expression instanceof ArrayExpression)
+        if (is(expression, ArrayExpression))
             return expression.elements.map((e) => this.render(e)).join(", ");
-        if (expression instanceof Operator.Not)
+        if (is(expression, Operator.Not))
             return `NOT (${this.render(expression.argument)})`;
-        if (expression instanceof Operator.IsNull)
+        if (is(expression, Operator.IsNull))
             return `${this.render(expression.argument)} IS NULL`;
-        if (expression instanceof Operator.IsNotNull)
+        if (is(expression, Operator.IsNotNull))
             return `${this.render(expression.argument)} IS NOT NULL`;
-        if (expression instanceof Operator.Exists)
+        if (is(expression, Operator.Exists))
             return `EXISTS ${this.render(expression.argument)}`;
-        if (expression instanceof Subquery)
+        if (is(expression, 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) && 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 (expression instanceof Operator.In &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof Subquery)
+        if (is(expression, Operator.In) && is(expression.left, Identifier) && is(expression.right, 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) && 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 (expression instanceof Operator.NotIn &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof 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 ((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) || 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 (expression instanceof Operator.Between)
+        if (is(expression, Operator.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))
             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))
             return `${this.wrap(expression.left, true)} AND ${this.wrap(expression.right, true)}`;
-        if (expression instanceof Operator.Or)
+        if (is(expression, Operator.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) && is(operands.right, 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) && 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)}`;
@@ -74,23 +67,27 @@ 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 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 inline = (value) => value === null
     ? "null"
     : typeof value === "boolean"
@@ -98,24 +95,25 @@ 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)
     ? 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) ||
+        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.14",
+  "version": "0.1.16",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",