@itrocks/mysql-maintainer 0.2.5 → 0.2.7

package/README.md

@@ -8,267 +8,87 @@
 
 Reactively maintains database structure by updating schema and retrying on MySQL errors.
 
-*This documentation was written by an artificial intelligence and may contain errors or approximations.
-It has not yet been fully reviewed by a human. If anything seems unclear or incomplete,
-please feel free to contact the author of this package.*
+Connect this package to [`@itrocks/mysql`](https://github.com/itrocks-ts/mysql), then keep using your MySQL data
+sources normally. Their database structure is maintained automatically, as operations need it, when persistent object
+structures evolve. There are no migration files to write and no maintenance API to call.
 
-## Installation
+## Use with the it.rocks framework
 
-```bash
-npm i @itrocks/mysql-maintainer
-```
-
-## Usage
-
-`@itrocks/mysql-maintainer` provides two main entry points:
-
-- the `Mysql` class, a drop‑in replacement for `@itrocks/mysql` that
-  automatically keeps your MySQL/MariaDB schema in sync with your
-  TypeScript models while you work with data;
-- the `MysqlMaintainer` class, a lower‑level helper you can call
-  directly when you want to create or update tables yourself.
-
-In both cases, the package reacts to common MySQL errors
-(`ER_BAD_FIELD_ERROR`, `ER_CANNOT_ADD_FOREIGN`, `ER_NO_SUCH_TABLE`) and
-updates the database structure, then transparently retries the failed
-query.
-
-### Minimal example: automatic schema maintenance
-
-```ts
-import { Mysql } from '@itrocks/mysql-maintainer'
-import { Entity } from '@itrocks/storage'
-
-class User extends Entity<User>
-{
-  name  = ''
-  email = ''
-}
-
-async function main() {
-  const mysql = new Mysql({
-    // Same connection options as @itrocks/mysql / mariadb
-    host: 'localhost',
-    user: 'root',
-    database: 'demo',
-  })
-
-  // On first call, mysql-maintainer will create or update the
-  // corresponding table based on the User class definition, then retry
-  // the insert.
-  await mysql.insert(new User().assign({ name: 'Alice', email: 'a@example.com' }))
-}
-```
-
-You can continue using the `Mysql` instance as you would use
-`@itrocks/mysql`: methods such as `read`, `search`, `update`, and
-collection helpers are forwarded to the base implementation, while
-`mysql-maintainer` keeps track of the involved entities and adjusts the
-schema when needed.
-
-### Example: maintaining join tables on collection access
-
-When you read many‑to‑many relationships defined as collections on your
-entities, `Mysql` automatically creates or updates the implicit join
-table.
+An application based on [`@itrocks/framework`](https://github.com/itrocks-ts/framework) needs the framework, the MySQL
+data source, and this package:
 
-```ts
-import { Mysql }   from '@itrocks/mysql-maintainer'
-import { Entity }  from '@itrocks/storage'
-
-class Tag extends Entity<Tag>
-{
-  name = ''
-}
-
-class Article extends Entity<Article>
-{
-  title = ''
-
-  // Many-to-many with Tag; the framework will map this to a join table
-  tags: Tag[] = []
-}
-
-async function loadArticleTags(id: number) {
-  const mysql = new Mysql({ database: 'demo' })
-
-  const article = await mysql.read(Article, id)
-
-  // If the join table does not exist yet or is out of date, it will be
-  // created/updated before the query is retried.
-  const tags = await mysql.readCollection(article, 'tags')
-  return tags
-}
-```
-
-### Example: using MysqlMaintainer directly
-
-If you want to control when schema updates happen (for instance during a
-deployment step or a migration command), you can work with
-`MysqlMaintainer` and a `mariadb` connection.
-
-```ts
-import { createConnection } from 'mariadb'
-import { MysqlMaintainer }  from '@itrocks/mysql-maintainer'
-import { Entity }           from '@itrocks/storage'
-
-class Product extends Entity<Product>
-{
-  name  = ''
-  price = 0
-}
-
-async function ensureSchema() {
-  const connection     = await createConnection({ database: 'demo' })
-  const schemaManager  = new MysqlMaintainer(connection)
-
-  // Create or update the table corresponding to Product
-  await schemaManager.updateTable(Product)
-
-  await connection.end()
-}
+```bash
+npm i @itrocks/framework @itrocks/mysql @itrocks/mysql-maintainer
 ```
 
-## API
+Add the composition and the main MySQL data source to the project's `config.yaml`:
 
-### `class Mysql extends @itrocks/mysql.Mysql`
+```yaml
+compose:
+  '@itrocks/mysql:Mysql': '@itrocks/mysql-maintainer:Mysql'
 
-Enhanced MySQL storage class that automatically tracks the context of
-operations and lets `MysqlMaintainer` react to schema‑related errors.
-
-Aside from the behavior described below, it exposes the same public API
-as `@itrocks/mysql.Mysql`.
-
-#### Properties
-
-- `connection?: ContextualConnection` – the underlying `mariadb`
-  connection wrapped with additional context information. You normally
-  do not interact with it directly.
-
-#### Methods
-
-All methods have the same signature and return types as in
-`@itrocks/mysql.Mysql`; the extra behavior is that each call pushes the
-relevant entity type or instance to an internal context stack before the
-query, and pops it afterwards.
-
-- `async connect(): Promise<ContextualConnection>`
-
-  Opens the connection and installs the contextual behavior so that
-  errors can trigger schema maintenance.
-
-- `async insert<T extends object>(object: T): Promise<Entity<T>>`
-
-  Inserts a new row for `object`. If a “table does not exist” or
-  “column not found / foreign key failed” error occurs, the
-  corresponding table (and, for collections, the join table) is created
-  or updated and the query is retried.
-
-- `async update<T extends object>(object: Entity<T>): Promise<Entity<T>>`
-
-  Updates an existing row; schema maintenance/automatic retry applies in
-  the same way as for `insert`.
-
-- `async deleteId<T extends object>(type: ObjectOrType<T>, id: any, property?: KeyOf<Entity<T>>): Promise<void>`
-
-  Deletes a row by its identifier; the entity `type` is used as context
-  for potential schema updates.
-
-- `async deleteRelatedId<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>`
-
-  Deletes a related entity (for example from a collection association).
-
-- `async read<T extends object>(type: Type<T>, id: Identifier): Promise<Entity<T> | undefined>`
-
-  Reads a single entity instance by identifier.
-
-- `async readMultiple<T extends object>(type: Type<T>, ids: Identifier[]): Promise<Entity<T>[]>`
-
-  Reads several entities by their identifiers.
-
-- `async readCollection<T extends object, PT extends object>(object: Entity<T>, property: KeyOf<T>, type?: Type<PT>): Promise<Entity<PT>[]>`
-
-  Reads a collection relationship (for example `article.tags`). The
-  context includes both the owning object and the related type so that
-  the implicit join table can be created or updated if necessary.
-
-- `async readCollectionIds<T extends object, PT extends object>(object: Entity<T>, property: KeyOf<T>, type?: Type<PT>): Promise<Identifier[]>`
-
-  Same as `readCollection`, but only retrieves identifiers.
-
-- `async search<T extends object>(type: Type<T>, search?: SearchType<T>, options?: Options): Promise<Entity<T>[]>`
-
-  Searches entities; the entity `type` becomes the context for schema
-  maintenance.
-
-### `class MysqlMaintainer`
-
-Low‑level utility that knows how to translate your TypeScript entity
-definitions (via reflection and schema packages) into MySQL tables and
-how to react to common schema‑related errors.
-
-#### Constructor
-
-```ts
-const maintainer = new MysqlMaintainer(connection)
+dataSource:
+  engine: '@itrocks/mysql'
+  host: localhost
+  user: application
+  password: secret
+  database: application
 ```
 
-- `connection` – a `mariadb` `Connection` used to inspect and modify the
-  database schema.
-
-#### Methods
+The `compose` entry enriches `@itrocks/mysql` with the automatic maintenance behaviour. It uses the standard
+[`@itrocks/compose`](https://github.com/itrocks-ts/compose) mechanism for enriching one module with another module's
+features.
 
-- `async createImplicitTable(type1: ObjectOrType, type2: ObjectOrType): Promise<boolean>`
+The `dataSource` entry above configures the project's main data source. You can instead create other MySQL data sources
+as described in the [`@itrocks/mysql` documentation](https://github.com/itrocks-ts/mysql). Every data source based on
+the composed `@itrocks/mysql` implementation is maintained automatically.
 
-  Creates a join table between the two entity types, with a composite
-  primary key and cascading foreign keys. Returns `true` once the table
-  has been created.
+That is the complete setup. Keep changing and using persistent object classes through the usual it.rocks storage
+operations; the required database changes are applied when an operation first needs them.
 
-- `async createTable(type: Type): Promise<boolean>`
+## Use outside the it.rocks framework
 
-  Creates a table corresponding to the given entity `type`. Throws if no
-  table name can be resolved for the type.
+The same integration principle can be used without `@itrocks/framework`:
 
-- `implicitTableName(type1: ObjectOrType, type2: ObjectOrType): string`
+1. Install [`@itrocks/mysql`](https://github.com/itrocks-ts/mysql) and a mixin-based composition system such as
+   [`@itrocks/compose`](https://github.com/itrocks-ts/compose). A wrapper implementing the same API as `@itrocks/mysql`
+   can be used instead.
+2. Create the required `@itrocks/mysql` data sources as described in its
+   [documentation](https://github.com/itrocks-ts/mysql). This package does not change how data sources are configured.
+3. Install `@itrocks/mysql-maintainer` in the project.
+4. Use the chosen composition system to enrich the `Mysql` implementation from `@itrocks/mysql` with the behaviour
+   supplied by `@itrocks/mysql-maintainer`. Refer to the
+   [`@itrocks/compose` documentation](https://github.com/itrocks-ts/compose) when using that package.
+5. Use the MySQL data sources normally. Their operations now trigger automatic maintenance when the current database
+   structure no longer supports the persistent object model.
 
-  Returns the name of the join table that would be used for a
-  many‑to‑many association between `type1` and `type2`. Throws if one of
-  the types is not mapped to a table.
+The application integrator is responsible for performing the composition early enough and according to the chosen
+composition system's loading rules.
 
-- `async manageError(error: SqlError, context: Context, sql: string | QueryOptions, values: any[]): Promise<boolean>`
+## How it works
 
-  Examines the MySQL error and, when it corresponds to a managed error
-  code, updates the tables for the provided `context` (entity type,
-  instance, or pair `[owner, relatedType]`). Returns `true` if the error
-  has been handled and the caller should retry the query, `false`
-  otherwise.
+The package enriches the usual `Mysql` operations with the context required to identify the persistent classes involved.
+It intercepts MySQL errors that indicate a missing or outdated table, column, or foreign key, derives the expected
+schema from the object model, applies the required structural changes, and retries the original operation.
 
-- `async updateContextTables(context: Context, tableName?: string): Promise<boolean>`
+For example, a read follows this simplified sequence:
 
-  Internal helper that inspects the database to see whether the table
-  for each context entity already exists. If not, it calls
-  `createTable`; otherwise it calls `updateTable`. When two contexts are
-  provided and their implicit join table matches `tableName`, the join
-  table is also created.
+1. The application reads an object through a MySQL data source as usual.
+2. The enriched data source records the class being read and executes the SQL query.
+3. If MySQL reports a supported structure error, the maintainer compares the database with the schema derived from
+   that class and updates the affected table or relationship table.
+4. The data source retries the same query and returns the read result to the application.
 
-- `async updateTable(type: Type): Promise<boolean>`
+The exported classes that implement context tracking, error handling, schema updates, and retries are internal
+mechanics of this integration. They are not a separate API that an application needs to call.
 
-  Computes the difference between the current MySQL table and the table
-  that should exist according to the entity `type`, then applies the
-  required SQL changes. Returns `true` when a change has been applied,
-  `false` when the schema was already up to date.
+## Persistent model requirements
 
-## Typical use cases
+Automatic maintenance derives database structure from business classes and their reflection metadata. Those classes
+must follow the it.rocks persistent object conventions, including the decorators and metadata used by its ORM packages.
 
-- Rapid prototyping: evolve your TypeScript entity models and let
-  `mysql-maintainer` adjust the database schema on the fly while you
-  insert, update, or query data.
-- Developer workstations and test environments where automatic schema
-  updates remove the need for manual migrations.
-- Applications with many small deployments where you prefer incremental
-  schema evolution handled by the application itself.
-- Projects using the `@itrocks/storage` / `@itrocks/mysql` stack that
-  want schema maintenance without writing migration scripts.
-- Custom migration tools or CLI scripts built on top of
-  `MysqlMaintainer` to validate and update schema before a new version
-  of the application is started.
+The current implementation is strongly coupled to the it.rocks ORM ecosystem. Its
+[`npm dependencies`](https://www.npmjs.com/package/@itrocks/mysql-maintainer?activeTab=dependencies) show the
+reflection, storage, schema conversion, and schema diff modules involved. Outside a full it.rocks application, the
+integrator must provide a compatible model and metadata environment in addition to the MySQL and composition
+integrations described above.

package/package.json

@@ -17,7 +17,7 @@
 	},
 	"description": "Reactively maintains database structure by updating schema and retrying on MySQL errors",
 	"devDependencies": {
-		"typescript": "^6.0"
+		"typescript": "^7.0"
 	},
 	"engines": {
 		"node": ">=24"
@@ -51,5 +51,5 @@
 	"scripts": {
 		"build": "tsc"
 	},
-	"version": "0.2.5"
+	"version": "0.2.7"
 }

package/cjs/contextual-connection.d.ts

@@ -1,16 +0,0 @@
-import { ObjectOrType } from '@itrocks/class-type';
-import { Connection } from 'mariadb';
-import { QueryOptions } from 'mariadb-share';
-import { SqlError } from 'mariadb-share';
-export type Context = ObjectOrType | ObjectOrType[];
-export declare class Contextual implements Partial<Connection> {
-    [x: number]: (() => Promise<void>) | undefined;
-    contexts: Context[];
-    errorCount: Record<string, Record<string, Array<number>>>;
-    superQuery: <T = any>(sql: string | QueryOptions, values?: any) => Promise<T>;
-    applyTo(connection: ContextualConnection): Promise<ContextualConnection>;
-    incrementErrorCount(sql: string, error: any): this is Connection;
-    isSqlError(error: any): error is SqlError;
-    query<T = any>(sql: string | QueryOptions, values?: any): Promise<T>;
-}
-export type ContextualConnection = Connection & Contextual;

package/cjs/contextual-connection.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Contextual = void 0;
-const mysql_maintainer_1 = require("./mysql-maintainer");
-const mysql_maintainer_2 = require("./mysql-maintainer");
-const MANAGED_ERROR_CODES = ['ER_BAD_FIELD_ERROR', 'ER_CANNOT_ADD_FOREIGN', 'ER_NO_SUCH_TABLE'];
-class Contextual {
-    contexts = [];
-    errorCount = {};
-    superQuery = () => new Promise(() => { });
-    async applyTo(connection) {
-        connection.contexts = [];
-        connection.errorCount = {};
-        connection.incrementErrorCount = Contextual.prototype.incrementErrorCount;
-        connection.isSqlError = Contextual.prototype.isSqlError;
-        connection.superQuery = connection.query;
-        connection.query = Contextual.prototype.query;
-        return connection;
-    }
-    incrementErrorCount(sql, error) {
-        if (!this.errorCount[sql]) {
-            this.errorCount[sql] = {};
-        }
-        if (!this.errorCount[sql][error.message]) {
-            this.errorCount[sql][error.message] = [];
-        }
-        this.errorCount[sql][error.message].push(new Date().getTime());
-        console.log('incremented', this.errorCount[sql][error.message].length, ':', sql, error.message);
-        return true;
-    }
-    isSqlError(error) {
-        return (typeof error === 'object') && !!error.code;
-    }
-    async query(sql, values) {
-        try {
-            if (mysql_maintainer_1.DEBUG)
-                console.log(sql, values);
-            return await this.superQuery(sql, values);
-        }
-        catch (error) {
-            if (!this.isSqlError(error) || !MANAGED_ERROR_CODES.includes(error.code)) {
-                if (mysql_maintainer_1.DEBUG)
-                    console.log('MAINTAINER: throw', error);
-                throw error;
-            }
-            sql = (typeof sql === 'object') ? sql.sql : sql;
-            if (this.incrementErrorCount(sql, error)
-                && (this.errorCount[sql][error.message].length < 5)
-                && await new mysql_maintainer_2.MysqlMaintainer(this).manageError(error, this.contexts[this.contexts.length - 1], sql, values)) {
-                return this.query(sql, values);
-            }
-            if (mysql_maintainer_1.DEBUG)
-                console.log('MAINTAINER: throw (2)', error);
-            throw error;
-        }
-    }
-}
-exports.Contextual = Contextual;
-//# sourceMappingURL=contextual-connection.js.map

package/cjs/mysql-maintainer.d.ts

@@ -1,18 +0,0 @@
-import { ObjectOrType } from '@itrocks/class-type';
-import { Type } from '@itrocks/class-type';
-import { Connection } from 'mariadb';
-import { QueryOptions } from 'mariadb-share';
-import { SqlError } from 'mariadb-share';
-import { Context } from './contextual-connection';
-export { Mysql } from './mysql';
-export declare const DEBUG = false;
-export declare class MysqlMaintainer {
-    connection: Connection;
-    constructor(connection: Connection);
-    createImplicitTable(type1: ObjectOrType, type2: ObjectOrType): Promise<boolean>;
-    createTable(type: Type): Promise<boolean>;
-    implicitTableName(type1: ObjectOrType, type2: ObjectOrType): string;
-    manageError(error: SqlError, context: Context, _sql: string | QueryOptions, _values: any[]): Promise<boolean>;
-    updateContextTables(context: Context, tableName?: string): Promise<boolean>;
-    updateTable(type: Type): Promise<boolean>;
-}

package/cjs/mysql-maintainer.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MysqlMaintainer = exports.DEBUG = exports.Mysql = void 0;
-const class_type_1 = require("@itrocks/class-type");
-const mysql_1 = require("@itrocks/mysql");
-const mysql_to_schema_1 = require("@itrocks/mysql-to-schema");
-const reflect_to_schema_1 = require("@itrocks/reflect-to-schema");
-const schema_diff_1 = require("@itrocks/schema-diff");
-const schema_diff_mysql_1 = require("@itrocks/schema-diff-mysql");
-const schema_to_mysql_1 = require("@itrocks/schema-to-mysql");
-const store_1 = require("@itrocks/store");
-var mysql_2 = require("./mysql");
-Object.defineProperty(exports, "Mysql", { enumerable: true, get: function () { return mysql_2.Mysql; } });
-exports.DEBUG = false;
-const DELETION = false;
-class MysqlMaintainer {
-    connection;
-    constructor(connection) {
-        this.connection = connection;
-    }
-    async createImplicitTable(type1, type2) {
-        const joinTable = this.implicitTableName(type1, type2);
-        const table1 = (0, store_1.storeOf)(type1);
-        const table2 = (0, store_1.storeOf)(type2);
-        const query = `CREATE TABLE \`${joinTable}\` (
-${table1}_id int unsigned NOT NULL,
-${table2}_id int unsigned NOT NULL,
-PRIMARY KEY (${table1}_id, ${table2}_id),
-CONSTRAINT \`${joinTable}.${table1}_id\` FOREIGN KEY (${table1}_id) REFERENCES \`${table1}\` (id) ON DELETE CASCADE ON UPDATE CASCADE,
-CONSTRAINT \`${joinTable}.${table2}_id\` FOREIGN KEY (${table2}_id) REFERENCES \`${table2}\` (id) ON DELETE CASCADE ON UPDATE CASCADE
-)`;
-        await this.connection.query(query);
-        return true;
-    }
-    async createTable(type) {
-        const tableName = (0, store_1.storeOf)(type);
-        if (!tableName) {
-            throw 'No table name for type';
-        }
-        const tableSchema = new reflect_to_schema_1.ReflectToTable().convert(type);
-        const schemaToMysql = new schema_to_mysql_1.SchemaToMysql();
-        const sql = schemaToMysql.sql(tableSchema);
-        await this.connection.query(sql);
-        return true;
-    }
-    implicitTableName(type1, type2) {
-        const table1 = (0, store_1.storeOf)(type1);
-        const table2 = (0, store_1.storeOf)(type2);
-        if (!table1 || !table2) {
-            throw 'Collection objects are not stored';
-        }
-        return (0, mysql_1.joinTableName)(table1, table2);
-    }
-    async manageError(error, context, _sql, _values) {
-        if (exports.DEBUG)
-            console.log('MAINTAINER: manageError', error);
-        switch (error.code) {
-            case 'ER_BAD_FIELD_ERROR':
-            case 'ER_CANNOT_ADD_FOREIGN':
-                return this.updateContextTables(context);
-            case 'ER_NO_SUCH_TABLE':
-                const tableName = /Table '.*?\.(.*?)'/.exec(error.message)?.[1];
-                return this.updateContextTables(context, tableName);
-        }
-        return false;
-    }
-    async updateContextTables(context, tableName) {
-        let result = false;
-        const contexts = Array.isArray(context) ? context : [context];
-        for (const context of contexts) {
-            const type = (0, class_type_1.typeOf)(context);
-            const tableName = (0, store_1.storeOf)(type);
-            if (!tableName) {
-                throw 'No table name for type';
-            }
-            const exists = (await this.connection.query('SHOW TABLES LIKE ?', tableName));
-            result ||= await (exists.length ? this.updateTable(type) : this.createTable(type));
-        }
-        if ((contexts.length === 2) && (this.implicitTableName(contexts[0], contexts[1]) === tableName)) {
-            result ||= await this.createImplicitTable(contexts[0], contexts[1]);
-        }
-        return result;
-    }
-    async updateTable(type) {
-        const tableName = (0, store_1.storeOf)(type);
-        if (!tableName) {
-            throw 'No table name for type';
-        }
-        const classTable = new reflect_to_schema_1.ReflectToTable().convert(type);
-        new mysql_to_schema_1.MysqlToTable(this.connection).normalize(classTable);
-        const mysqlTable = await ((new mysql_to_schema_1.MysqlToTable(this.connection)).convert(tableName));
-        const schemaDiff = new schema_diff_1.TableDiff(mysqlTable, classTable);
-        if (!schemaDiff.additions.length
-            && !schemaDiff.changes.length
-            && (!schemaDiff.deletions.length || !DELETION)
-            && !schemaDiff.tableChanges()) {
-            return false;
-        }
-        const schemaDiffMysql = new schema_diff_mysql_1.SchemaDiffMysql();
-        const sql = schemaDiffMysql.sql(schemaDiff, DELETION);
-        await this.connection.query(sql);
-        return true;
-    }
-}
-exports.MysqlMaintainer = MysqlMaintainer;
-//# sourceMappingURL=mysql-maintainer.js.map

package/cjs/mysql.d.ts

@@ -1,26 +0,0 @@
-import { ObjectOrType } from '@itrocks/class-type';
-import { Type } from '@itrocks/class-type';
-import { Mysql as M } from '@itrocks/mysql';
-import { Entity } from '@itrocks/storage';
-import { Identifier } from '@itrocks/storage';
-import { MayEntity } from '@itrocks/storage';
-import { Options } from '@itrocks/storage';
-import { SearchType } from '@itrocks/storage';
-import { ContextualConnection } from './contextual-connection';
-export declare class Mysql extends M {
-    connection?: ContextualConnection;
-    connect(): Promise<ContextualConnection>;
-    deleteId<T extends object>(type: ObjectOrType<T>, id: any, property?: keyof Entity<T>): Promise<void>;
-    deleteRelatedId<T extends Entity>(object: T, property: keyof T, id: Identifier): Promise<void>;
-    insert<T extends object>(object: T): Promise<Entity<T>>;
-    insertRelatedId<T extends Entity>(object: T, property: keyof T, id: Identifier): Promise<void>;
-    read<T extends object>(type: Type<T>, id: Identifier): Promise<Entity<T>>;
-    readCollection<T extends object, PT extends object>(object: Entity<T>, property: keyof T, type?: Type<PT>): Promise<Awaited<PT & {
-        id: Identifier;
-    }>[]>;
-    readCollectionIds<T extends object, PT extends object>(object: Entity<T>, property: keyof T, type?: Type<PT>): Promise<Identifier[]>;
-    readMultiple<T extends object>(type: Type<T>, ids: Identifier[]): Promise<Entity<T>[]>;
-    save<T extends object>(object: MayEntity<T>): Promise<Entity<T>>;
-    search<T extends object>(type: Type<T>, search?: SearchType<T>, options?: Options): Promise<Entity<T>[]>;
-    update<T extends object>(object: Entity<T>): Promise<Entity<T>>;
-}

package/cjs/mysql.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mysql = void 0;
-const mysql_1 = require("@itrocks/mysql");
-const reflect_1 = require("@itrocks/reflect");
-const contextual_connection_1 = require("./contextual-connection");
-class Mysql extends mysql_1.Mysql {
-    async connect() {
-        return contextual_connection_1.Contextual.prototype.applyTo(await super.connect());
-    }
-    async deleteId(type, id, property = 'id') {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(type);
-        const result = await super.deleteId(type, id, property);
-        contexts.pop();
-        return result;
-    }
-    async deleteRelatedId(object, property, id) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(object);
-        const result = await super.deleteRelatedId(object, property, id);
-        contexts.pop();
-        return result;
-    }
-    async insert(object) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(object);
-        const result = await super.insert(object);
-        contexts.pop();
-        return result;
-    }
-    async insertRelatedId(object, property, id) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(object);
-        const result = await super.insertRelatedId(object, property, id);
-        contexts.pop();
-        return result;
-    }
-    async read(type, id) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(type);
-        const result = await super.read(type, id);
-        contexts.pop();
-        return result;
-    }
-    async readCollection(object, property, type) {
-        type ??= new reflect_1.ReflectProperty(object, property).collectionType.elementType.type;
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push([object, type]);
-        const result = await super.readCollection(object, property, type);
-        contexts.pop();
-        return result;
-    }
-    async readCollectionIds(object, property, type) {
-        type ??= new reflect_1.ReflectProperty(object, property).collectionType.elementType.type;
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push([object, type]);
-        const result = await super.readCollectionIds(object, property, type);
-        contexts.pop();
-        return result;
-    }
-    async readMultiple(type, ids) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(type);
-        const result = await super.readMultiple(type, ids);
-        contexts.pop();
-        return result;
-    }
-    async save(object) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(object);
-        const result = await super.save(object);
-        contexts.pop();
-        return result;
-    }
-    async search(type, search = {}, options) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(type);
-        const result = await super.search(type, search, options);
-        contexts.pop();
-        return result;
-    }
-    async update(object) {
-        const contexts = (this.connection ?? await this.connect()).contexts;
-        contexts.push(object);
-        const result = await super.update(object);
-        contexts.pop();
-        return result;
-    }
-}
-exports.Mysql = Mysql;
-//# sourceMappingURL=mysql.js.map