@deterministic-code/datasources 0.1.1 → 0.1.2

package/dist/statements/Subquery.js

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

package/dist/statements/UniqueConstraint.js

@@ -0,0 +1,9 @@
+export class UniqueConstraint {
+    name;
+    columns;
+    kind = "unique";
+    constructor(name, columns) {
+        this.name = name;
+        this.columns = columns;
+    }
+}

package/dist/statements/UpdateStatement.js

@@ -0,0 +1,19 @@
+import { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
+import { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export class UpdateStatement {
+    table;
+    fields;
+    where;
+    constructor(table, fields, where) {
+        this.table = table;
+        this.fields = fields;
+        this.where = where;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return new UpdateStatementTextRenderer(DefaultStatementTextRenderer.instance)
+            .compose(`UPDATE ${this.table} SET ${this.fields.map((item) => `${item.name} = $${item.name}`).join(", ")}`, this.where, this.fields).parameters;
+    }
+    static parameterList = (fields, where) => new UpdateStatementTextRenderer(DefaultStatementTextRenderer.instance).compose("", where, fields)
+        .parameters;
+}

package/dist/statements/UpdateStatementTextRenderer.js

@@ -0,0 +1,51 @@
+const rename = (text, name, alias) => {
+    const token = `$${name}`;
+    const next = `$${alias}`;
+    let index = 0;
+    let result = "";
+    while (text.indexOf(token, index) >= 0) {
+        const at = text.indexOf(token, index);
+        const end = at + token.length;
+        const nextChar = text.charAt(end);
+        const boundary = nextChar === "" || !/[A-Za-z0-9_]/.test(nextChar);
+        result += text.slice(index, at) + (boundary ? next : token);
+        index = end;
+    }
+    return result + text.slice(index);
+};
+const setClause = (fields) => fields.map((field) => `${field.name} = $${field.name}`).join(", ");
+export class UpdateStatementTextRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render(statement) {
+        return this.compose(`UPDATE ${statement.table} SET ${setClause(statement.fields)}`, statement.where, statement.fields).text;
+    }
+    compose(sql, where, fields) {
+        if (!where)
+            return { text: sql, parameters: fields };
+        const rendered = `${sql} WHERE ${this.text.render(where)}`;
+        const split = rendered.lastIndexOf(" WHERE ");
+        /* v8 ignore next 2 */
+        const head = split < 0 ? rendered : rendered.slice(0, split);
+        let tail = split < 0 ? "" : rendered.slice(split);
+        const parameters = [...fields];
+        const values = new Map();
+        for (const field of fields)
+            values.set(field.name, field.value);
+        for (const parameter of where.parameters ?? []) {
+            if (parameter.value === undefined)
+                continue;
+            const current = values.get(parameter.name);
+            if (values.has(parameter.name) && current !== parameter.value) {
+                const alias = `${parameter.name}__where`;
+                tail = rename(tail, parameter.name, alias);
+                parameters.push({ name: alias, value: parameter.value });
+            }
+            else
+                parameters.push({ name: parameter.name, value: parameter.value });
+        }
+        return { text: head + tail, parameters };
+    }
+}

package/dist/statements/Where.js

@@ -0,0 +1,182 @@
+import { ArrayExpression } from "./ArrayExpression.js";
+import { Identifier } from "./Identifier.js";
+import { Literal } from "./Literal.js";
+import { Operator } from "./Operator.js";
+import { eq } from "./Cmp.js";
+import { SelectStatement } from "./SelectStatement.js";
+import { Subquery } from "./Subquery.js";
+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
+    ? expression
+    : undefined;
+const parameterName = (name) => parts(name)
+    .map((part) => part.length >= 2 && part.startsWith('"') && part.endsWith('"')
+    ? part.slice(1, -1).replace(/""/g, '"')
+    : part)
+    .join(".");
+const parts = (name) => {
+    const found = [];
+    let start = 0;
+    let quoted = false;
+    for (let i = 0; i < name.length; i++) {
+        if (name[i] === '"')
+            quoted = !quoted;
+        if (name[i] !== "." || quoted)
+            continue;
+        found.push(name.slice(start, i));
+        start = i + 1;
+    }
+    found.push(name.slice(start));
+    return found;
+};
+const side = (expression, other, column, value) => expression instanceof Literal && other instanceof Identifier
+    ? new Literal(value(other.name, expression.value))
+    : rewrite(expression, column, value);
+const inRight = (left, right, column, value) => left instanceof Identifier && right instanceof ArrayExpression
+    ? new ArrayExpression(right.elements.map((element) => element instanceof Literal
+        ? new Literal(value(left.name, element.value))
+        : rewrite(element, column, value)))
+    : rewrite(right, column, value);
+const bound = (subject, edge, column, value) => subject instanceof Identifier && edge instanceof Literal
+    ? new Literal(value(subject.name, edge.value))
+    : rewrite(edge, column, value);
+const rewriteWhere = (where, column, value) => where instanceof Where ? new Where(rewrite(where.condition, column, value)) : where;
+const rewriteQuery = (query, column, value) => query.table === undefined
+    ? query
+    : new SelectStatement({
+        distinct: query.distinct,
+        table: query.table,
+        fields: query.fields,
+        where: rewriteWhere(query.where, column, value),
+        joins: query.joins.map((join) => join.on ? { ...join, on: rewrite(join.on, column, value) } : join),
+        groupBy: query.groupBy,
+        having: rewriteWhere(query.having, column, value),
+        orderBy: query.orderBy,
+        limit: query.limit,
+        offset: query.offset,
+    });
+const rewrite = (expression, column, value) => expression instanceof Where
+    ? rewrite(expression.condition, column, value)
+    : expression instanceof Identifier
+        ? new Identifier(column(expression.name))
+        : expression instanceof Literal
+            ? expression
+            : expression instanceof ArrayExpression
+                ? new ArrayExpression(expression.elements.map((element) => rewrite(element, column, value)))
+                : expression instanceof Subquery
+                    ? new Subquery(rewriteQuery(expression.query, column, value))
+                    : expression instanceof Operator.Not
+                        ? new Operator.Not(rewrite(expression.argument, column, value))
+                        : expression instanceof Operator.IsNull
+                            ? new Operator.IsNull(rewrite(expression.argument, column, value))
+                            : expression instanceof Operator.IsNotNull
+                                ? new Operator.IsNotNull(rewrite(expression.argument, column, value))
+                                : expression instanceof Operator.Exists
+                                    ? new Operator.Exists(rewrite(expression.argument, column, value))
+                                    : expression instanceof Operator.And
+                                        ? new Operator.And(rewrite(expression.left, column, value), rewrite(expression.right, column, value))
+                                        : expression instanceof Operator.Or
+                                            ? new Operator.Or(rewrite(expression.left, column, value), rewrite(expression.right, column, value))
+                                            : expression instanceof Operator.In
+                                                ? new Operator.In(rewrite(expression.left, column, value), inRight(expression.left, expression.right, column, value))
+                                                : expression instanceof Operator.NotIn
+                                                    ? new Operator.NotIn(rewrite(expression.left, column, value), inRight(expression.left, expression.right, column, value))
+                                                    : expression instanceof Operator.Like
+                                                        ? new Operator.Like(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                        : expression instanceof Operator.NotLike
+                                                            ? new Operator.NotLike(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                            : expression instanceof Operator.Between
+                                                                ? new Operator.Between(rewrite(expression.value, column, value), bound(expression.value, expression.low, column, value), bound(expression.value, expression.high, column, value))
+                                                                : expression instanceof Operator.NotBetween
+                                                                    ? new Operator.NotBetween(rewrite(expression.value, column, value), bound(expression.value, expression.low, column, value), bound(expression.value, expression.high, column, value))
+                                                                    : expression instanceof Operator.Equals
+                                                                        ? new Operator.Equals(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                        : expression instanceof Operator.NotEquals
+                                                                            ? new Operator.NotEquals(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                            : expression instanceof Operator.GreaterThan
+                                                                                ? new Operator.GreaterThan(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                : expression instanceof Operator.LessThan
+                                                                                    ? new Operator.LessThan(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                    : expression instanceof Operator.GreaterThanOrEqual
+                                                                                        ? new Operator.GreaterThanOrEqual(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                        : expression instanceof Operator.LessThanOrEqual
+                                                                                            ? new Operator.LessThanOrEqual(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                            : (() => {
+                                                                                                throw new Error("empty expression");
+                                                                                            })();
+const listed = (name, elements) => elements.map((element, i) => element instanceof Literal
+    ? { name: `${parameterName(name)}_${i}`, value: element.value }
+    : (() => {
+        throw new Error("empty in");
+    })());
+const collect = (expression) => {
+    if (expression instanceof Where)
+        return collect(expression.condition);
+    if (expression instanceof Literal || expression instanceof Identifier)
+        return [];
+    if (expression instanceof Operator.Not || expression instanceof Operator.IsNull || expression instanceof Operator.IsNotNull)
+        return collect(expression.argument);
+    if (expression instanceof Operator.Exists)
+        return collect(expression.argument);
+    if (expression instanceof Subquery)
+        return [
+            ...(expression.query.where ? collect(expression.query.where) : []),
+            ...(expression.query.having ? collect(expression.query.having) : []),
+            ...expression.query.joins.flatMap((join) => (join.on ? collect(join.on) : [])),
+        ];
+    if (expression instanceof Operator.In && expression.left instanceof Identifier && expression.right instanceof ArrayExpression)
+        return listed(expression.left.name, expression.right.elements);
+    if (expression instanceof Operator.NotIn && expression.left instanceof Identifier && expression.right instanceof ArrayExpression)
+        return listed(expression.left.name, expression.right.elements);
+    if (expression instanceof Operator.In || expression instanceof Operator.NotIn)
+        return [...collect(expression.left), ...collect(expression.right)];
+    if ((expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
+        expression.value instanceof Identifier &&
+        expression.low instanceof Literal &&
+        expression.high instanceof Literal)
+        return [
+            { name: `${parameterName(expression.value.name)}_0`, value: expression.low.value },
+            { name: `${parameterName(expression.value.name)}_1`, value: expression.high.value },
+        ];
+    if (expression instanceof Operator.Between || expression instanceof Operator.NotBetween)
+        return [...collect(expression.value), ...collect(expression.low), ...collect(expression.high)];
+    const operands = expression instanceof Operator ? pair(expression) : undefined;
+    if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
+        return [{ name: parameterName(operands.left.name), value: operands.right.value }];
+    if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
+        return [];
+    if (operands)
+        return [...collect(operands.left), ...collect(operands.right)];
+    if (expression instanceof ArrayExpression)
+        return expression.elements.flatMap(collect);
+    throw new Error("empty expression");
+};
+export class Where {
+    condition;
+    constructor(columnOrCondition, op = eq, value = null) {
+        this.condition =
+            typeof columnOrCondition === "string" ? op(columnOrCondition, value) : columnOrCondition;
+    }
+    and(column, op, value) {
+        return new Where(new Operator.And(this.condition, op(column, value)));
+    }
+    or(column, op, value) {
+        return new Where(new Operator.Or(this.condition, op(column, value)));
+    }
+    map(column, value) {
+        return new Where(rewrite(this.condition, column, value));
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return collect(this.condition);
+    }
+}

package/dist/statements/WhereText.js

@@ -0,0 +1,10 @@
+export class WhereText {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    get rawText() {
+        return this.text;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/index.d.ts

@@ -13,6 +13,22 @@ export type { IBulkUpdateStatement } from "./IBulkUpdateStatement.js";
 export type { IBulkDeleteStatement } from "./IBulkDeleteStatement.js";
 export type { ICreateTableStatement } from "./ICreateTableStatement.js";
 export type { ICreateIndexStatement } from "./ICreateIndexStatement.js";
+export type { IDropTableStatement } from "./IDropTableStatement.js";
+export type { IAlterTableStatement } from "./IAlterTableStatement.js";
+export type { AlterAction } from "./AlterTableStatement.js";
+export type { IDropIndexStatement } from "./IDropIndexStatement.js";
+export type { IDropTriggerStatement } from "./IDropTriggerStatement.js";
+export type { ICreateTriggerStatement } from "./ICreateTriggerStatement.js";
+export type { IIdentityInsertStatement } from "./IIdentityInsertStatement.js";
+export type { IDropRoutineStatement } from "./IDropRoutineStatement.js";
+export type { ICreateCreateStoredProcedureStatement } from "./ICreateCreateStoredProcedureStatement.js";
+export type { ICreateReadStoredProcedureStatement } from "./ICreateReadStoredProcedureStatement.js";
+export type { ICreateUpdateStoredProcedureStatement } from "./ICreateUpdateStoredProcedureStatement.js";
+export type { ICreateDeleteStoredProcedureStatement } from "./ICreateDeleteStoredProcedureStatement.js";
+export type { ICreateBulkCreateStoredProcedureStatement } from "./ICreateBulkCreateStoredProcedureStatement.js";
+export type { ICreateBulkUpdateStoredProcedureStatement } from "./ICreateBulkUpdateStoredProcedureStatement.js";
+export type { ICreateBulkDeleteStoredProcedureStatement } from "./ICreateBulkDeleteStoredProcedureStatement.js";
+export type { RoutineParameter } from "./RoutineParameter.js";
 export type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.js";
 export type { IReturnStatement } from "./IReturnStatement.js";
 export type { Column } from "./Column.js";
@@ -56,6 +72,34 @@ export { CreateTableStatement } from "./CreateTableStatement.js";
 export { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
 export { CreateIndexStatement } from "./CreateIndexStatement.js";
 export { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.js";
+export { DropTableStatement } from "./DropTableStatement.js";
+export { DropTableStatementTextRenderer } from "./DropTableStatementTextRenderer.js";
+export { AlterTableStatement } from "./AlterTableStatement.js";
+export { AlterTableStatementTextRenderer } from "./AlterTableStatementTextRenderer.js";
+export { DropIndexStatement } from "./DropIndexStatement.js";
+export { DropIndexStatementTextRenderer } from "./DropIndexStatementTextRenderer.js";
+export { DropTriggerStatement } from "./DropTriggerStatement.js";
+export { DropTriggerStatementTextRenderer } from "./DropTriggerStatementTextRenderer.js";
+export { CreateTriggerStatement } from "./CreateTriggerStatement.js";
+export { CreateTriggerStatementTextRenderer } from "./CreateTriggerStatementTextRenderer.js";
+export { IdentityInsertStatement } from "./IdentityInsertStatement.js";
+export { IdentityInsertStatementTextRenderer } from "./IdentityInsertStatementTextRenderer.js";
+export { DropRoutineStatement } from "./DropRoutineStatement.js";
+export { DropRoutineStatementTextRenderer } from "./DropRoutineStatementTextRenderer.js";
+export { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
+export { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
+export { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+export { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+export { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
+export { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
+export { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
+export { CreateDeleteStoredProcedureStatementTextRenderer } from "./CreateDeleteStoredProcedureStatementTextRenderer.js";
+export { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
+export { CreateBulkCreateStoredProcedureStatementTextRenderer } from "./CreateBulkCreateStoredProcedureStatementTextRenderer.js";
+export { CreateBulkUpdateStoredProcedureStatement } from "./CreateBulkUpdateStoredProcedureStatement.js";
+export { CreateBulkUpdateStoredProcedureStatementTextRenderer } from "./CreateBulkUpdateStoredProcedureStatementTextRenderer.js";
+export { CreateBulkDeleteStoredProcedureStatement } from "./CreateBulkDeleteStoredProcedureStatement.js";
+export { CreateBulkDeleteStoredProcedureStatementTextRenderer } from "./CreateBulkDeleteStoredProcedureStatementTextRenderer.js";
 export { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.js";
 export { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.js";
 export { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";

package/dist/statements/index.js

@@ -0,0 +1,79 @@
+export { Join } from "./Join.js";
+export { Aggregate } from "./Aggregate.js";
+export { OrderBy } from "./OrderBy.js";
+export { Condition } from "./Condition.js";
+export { Operator } from "./Operator.js";
+export { eq, ne, gt, lt, ge, le } from "./Cmp.js";
+export { Identifier } from "./Identifier.js";
+export { Literal } from "./Literal.js";
+export { ArrayExpression } from "./ArrayExpression.js";
+export { Where } from "./Where.js";
+export { ExpressionEvaluator } from "./ExpressionEvaluator.js";
+export { StatementEvaluator } from "./StatementEvaluator.js";
+export { WhereText } from "./WhereText.js";
+export { SelectStatement } from "./SelectStatement.js";
+export { StatementParser } from "./StatementParser.js";
+export { StatementTextRenderer } from "./StatementTextRenderer.js";
+export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
+export { StatementRenderer } from "./StatementRenderer.js";
+export { ExpressionRenderer } from "./ExpressionRenderer.js";
+export { ConditionRenderer } from "./ConditionRenderer.js";
+export { Native, n } from "./Native.js";
+export { Subquery } from "./Subquery.js";
+export { InsertStatement } from "./InsertStatement.js";
+export { UpdateStatement } from "./UpdateStatement.js";
+export { DeleteStatement } from "./DeleteStatement.js";
+export { BulkInsertStatement } from "./BulkInsertStatement.js";
+export { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+export { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+export { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.js";
+export { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.js";
+export { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.js";
+export { CreateTableStatement } from "./CreateTableStatement.js";
+export { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+export { CreateIndexStatement } from "./CreateIndexStatement.js";
+export { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.js";
+export { DropTableStatement } from "./DropTableStatement.js";
+export { DropTableStatementTextRenderer } from "./DropTableStatementTextRenderer.js";
+export { AlterTableStatement } from "./AlterTableStatement.js";
+export { AlterTableStatementTextRenderer } from "./AlterTableStatementTextRenderer.js";
+export { DropIndexStatement } from "./DropIndexStatement.js";
+export { DropIndexStatementTextRenderer } from "./DropIndexStatementTextRenderer.js";
+export { DropTriggerStatement } from "./DropTriggerStatement.js";
+export { DropTriggerStatementTextRenderer } from "./DropTriggerStatementTextRenderer.js";
+export { CreateTriggerStatement } from "./CreateTriggerStatement.js";
+export { CreateTriggerStatementTextRenderer } from "./CreateTriggerStatementTextRenderer.js";
+export { IdentityInsertStatement } from "./IdentityInsertStatement.js";
+export { IdentityInsertStatementTextRenderer } from "./IdentityInsertStatementTextRenderer.js";
+export { DropRoutineStatement } from "./DropRoutineStatement.js";
+export { DropRoutineStatementTextRenderer } from "./DropRoutineStatementTextRenderer.js";
+export { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
+export { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
+export { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+export { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+export { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
+export { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
+export { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
+export { CreateDeleteStoredProcedureStatementTextRenderer } from "./CreateDeleteStoredProcedureStatementTextRenderer.js";
+export { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
+export { CreateBulkCreateStoredProcedureStatementTextRenderer } from "./CreateBulkCreateStoredProcedureStatementTextRenderer.js";
+export { CreateBulkUpdateStoredProcedureStatement } from "./CreateBulkUpdateStoredProcedureStatement.js";
+export { CreateBulkUpdateStoredProcedureStatementTextRenderer } from "./CreateBulkUpdateStoredProcedureStatementTextRenderer.js";
+export { CreateBulkDeleteStoredProcedureStatement } from "./CreateBulkDeleteStoredProcedureStatement.js";
+export { CreateBulkDeleteStoredProcedureStatementTextRenderer } from "./CreateBulkDeleteStoredProcedureStatementTextRenderer.js";
+export { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.js";
+export { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.js";
+export { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.js";
+export { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.js";
+export { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.js";
+export { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.js";
+export { ColumnDefault } from "./ColumnDefault.js";
+export { NotNull } from "./NotNull.js";
+export { PrimaryKey } from "./PrimaryKey.js";
+export { ForeignKey, ReferentialAction } from "./ForeignKey.js";
+export { UniqueConstraint } from "./UniqueConstraint.js";
+export { CheckConstraint } from "./CheckConstraint.js";
+export { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+export { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+export { ReturnStatement } from "./ReturnStatement.js";

package/dist/stubs/StubCommand.js

@@ -0,0 +1,13 @@
+import { CommandMiddlewareHost } from "../CommandMiddlewareHost.js";
+import { notImplemented } from "./notImplemented.js";
+export class StubCommand extends CommandMiddlewareHost {
+    provider;
+    connection;
+    constructor(provider, connection) {
+        super();
+        this.provider = provider;
+        this.connection = connection;
+    }
+    executeReaderNative = (text, parameters) => this.run(text.text, parameters, async () => notImplemented(this.provider));
+    executeNative = (text, parameters) => this.run(text.text, parameters, async () => notImplemented(this.provider));
+}

package/dist/stubs/StubConnection.js

@@ -0,0 +1,14 @@
+import { StubCommand } from "./StubCommand.js";
+import { notImplemented } from "./notImplemented.js";
+export class StubConnection {
+    provider;
+    isOpen = false;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    createCommand = () => new StubCommand(this.provider, this);
+    open = async () => notImplemented(this.provider);
+    close = async () => notImplemented(this.provider);
+    [Symbol.asyncDispose] = () => this.close();
+    startTransaction = async () => notImplemented(this.provider);
+}

package/dist/stubs/StubDatasource.js

@@ -0,0 +1,34 @@
+import { DatasourceError } from "../DatasourceError.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+import { StubCommand } from "./StubCommand.js";
+import { StubConnection } from "./StubConnection.js";
+import { StubRepository } from "./StubRepository.js";
+export class StubDatasource {
+    provider;
+    connection;
+    repositories = new RepositoryFactory();
+    constructor(provider) {
+        this.provider = provider;
+    }
+    defaultConnection = () => (this.connection ??= new StubConnection(this.provider));
+    createConnection = () => Promise.resolve(this.defaultConnection());
+    createCommand = async (connection) => {
+        if (!connection) {
+            connection = this.defaultConnection();
+            if (connection.isOpen)
+                throw new DatasourceError("Connection is already open");
+            await connection.open();
+        }
+        return new StubCommand(this.provider, connection);
+    };
+    createRepository(typeOrName, connection) {
+        if (typeof typeOrName === "string")
+            return this.repositories.create(typeOrName, connection ?? this.defaultConnection());
+        return new StubRepository(this.provider, connection ?? this.defaultConnection(), typeOrName);
+    }
+    createReadonlyRepository(typeOrName, connection) {
+        if (typeof typeOrName === "string")
+            return this.repositories.createReadonly(typeOrName, connection ?? this.defaultConnection());
+        return this.createRepository(typeOrName, connection);
+    }
+}

package/dist/stubs/StubReader.js

@@ -0,0 +1,20 @@
+import { readerToAsyncIterable } from "../readerToAsyncIterable.js";
+import { notImplemented } from "./notImplemented.js";
+export class StubReader {
+    provider;
+    current = undefined;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async next() {
+        notImplemented(this.provider);
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    async nextResult() {
+        notImplemented(this.provider);
+    }
+    async dispose() { }
+    [Symbol.asyncDispose] = () => this.dispose();
+}

package/dist/stubs/StubRepository.js

@@ -0,0 +1,17 @@
+import { ReadonlyRepository, untyped } from "../ReadonlyRepository.js";
+import { notImplemented } from "./notImplemented.js";
+export class StubRepository extends ReadonlyRepository {
+    provider;
+    ids = [];
+    constructor(provider, _connection, type = untyped()) {
+        super(type);
+        this.provider = provider;
+    }
+    async *read(_query, _parameters, _options) {
+        notImplemented(this.provider);
+    }
+    create = async (_item) => notImplemented(this.provider);
+    update = async (_item, _byWhere) => notImplemented(this.provider);
+    delete = async (_item, _byWhere) => notImplemented(this.provider);
+    readSingleById = (_id) => notImplemented(this.provider);
+}

package/dist/stubs/StubTransaction.js

@@ -0,0 +1,13 @@
+import { IsolationLevel } from "../IsolationLevel.js";
+import { notImplemented } from "./notImplemented.js";
+export class StubTransaction {
+    provider;
+    connection;
+    isolation = IsolationLevel.ReadCommitted;
+    constructor(provider, connection) {
+        this.provider = provider;
+        this.connection = connection;
+    }
+    commit = async () => notImplemented(this.provider);
+    abort = async () => notImplemented(this.provider);
+}

package/dist/stubs/createStubDatasource.js

@@ -0,0 +1,2 @@
+import { StubDatasource } from "./StubDatasource.js";
+export const createStubDatasource = (provider) => new StubDatasource(provider);

package/dist/stubs/index.js

@@ -0,0 +1,7 @@
+export { createStubDatasource } from "./createStubDatasource.js";
+export { StubCommand } from "./StubCommand.js";
+export { StubConnection } from "./StubConnection.js";
+export { StubDatasource } from "./StubDatasource.js";
+export { StubReader } from "./StubReader.js";
+export { StubRepository } from "./StubRepository.js";
+export { StubTransaction } from "./StubTransaction.js";

package/dist/stubs/notImplemented.js

@@ -0,0 +1,4 @@
+import { ProviderNotImplementedError } from "../ProviderNotImplementedError.js";
+export const notImplemented = (provider) => {
+    throw new ProviderNotImplementedError(provider);
+};

package/package.json

@@ -1,24 +1,23 @@
 {
   "name": "@deterministic-code/datasources",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./mocks": {
-      "types": "./dist/mocks/index.d.ts",
-      "import": "./src/mocks/index.ts",
-      "default": "./src/mocks/index.ts"
+      "types": "./dist/mocks/index.d.js",
+      "import": "./dist/mocks/index.js",
+      "default": "./dist/mocks/index.js"
     }
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"

package/src/ArrayReader.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ArrayReader } from "./index.ts";
-
-describe("ArrayReader", () => {
-  it("walks an array including the empty case", async () => {
-    const empty = new ArrayReader([]);
-    expect(empty.current).toBeUndefined();
-    expect(await empty.next()).toBe(false);
-    expect(empty.current).toBeUndefined();
-
-    const reader = new ArrayReader([{ id: 1 }, { id: 2 }]);
-    expect(await reader.next()).toBe(true);
-    expect(reader.current).toEqual({ id: 1 });
-    expect(await reader.next()).toBe(true);
-    expect(reader.current).toEqual({ id: 2 });
-    expect(await reader.next()).toBe(false);
-    expect(reader.current).toBeUndefined();
-    expect(await reader.nextResult()).toBe(false);
-    expect(await Array.fromAsync(new ArrayReader(["a", "b"]).read())).toEqual(["a", "b"]);
-    await reader.dispose();
-    await reader[Symbol.asyncDispose]();
-  });
-});