@mikro-orm/sql-js 7.2.0-dev.22

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,227 @@
+<h1 align="center">
+  <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
+</h1>
+
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
+
+> Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
+
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
+[![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
+
+## Quick Start
+
+Install a driver package for your database:
+
+```sh
+npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
+npm install @mikro-orm/mysql        # MySQL
+npm install @mikro-orm/mariadb      # MariaDB
+npm install @mikro-orm/sqlite       # SQLite
+npm install @mikro-orm/libsql       # libSQL / Turso
+npm install @mikro-orm/sql-js       # sql.js (in-memory SQLite in WASM)
+npm install @mikro-orm/mongodb      # MongoDB
+npm install @mikro-orm/mssql        # MS SQL Server
+npm install @mikro-orm/oracledb     # Oracle
+```
+
+> If you use additional packages like `@mikro-orm/cli`, `@mikro-orm/migrations`, or `@mikro-orm/entity-generator`, install `@mikro-orm/core` explicitly as well. See the [quick start guide](https://mikro-orm.io/docs/quick-start) for details.
+
+### Define Entities
+
+The recommended way to define entities is using [`defineEntity`](https://mikro-orm.io/docs/define-entity) with `setClass`:
+
+```typescript
+import { defineEntity, p, MikroORM } from '@mikro-orm/postgresql';
+
+const AuthorSchema = defineEntity({
+  name: 'Author',
+  properties: {
+    id: p.integer().primary(),
+    name: p.string(),
+    email: p.string(),
+    born: p.datetime().nullable(),
+    books: () => p.oneToMany(Book).mappedBy('author'),
+  },
+});
+
+export class Author extends AuthorSchema.class {}
+AuthorSchema.setClass(Author);
+
+const BookSchema = defineEntity({
+  name: 'Book',
+  properties: {
+    id: p.integer().primary(),
+    title: p.string(),
+    author: () => p.manyToOne(Author).inversedBy('books'),
+  },
+});
+
+export class Book extends BookSchema.class {}
+BookSchema.setClass(Book);
+```
+
+You can also define entities using [decorators](https://mikro-orm.io/docs/using-decorators) or [`EntitySchema`](https://mikro-orm.io/docs/define-entity#entityschema-low-level-api). See the [defining entities guide](https://mikro-orm.io/docs/defining-entities) for all options.
+
+### Initialize and Use
+
+```typescript
+import { MikroORM, RequestContext } from '@mikro-orm/postgresql';
+
+const orm = await MikroORM.init({
+  entities: [Author, Book],
+  dbName: 'my-db',
+});
+
+// Create new entities
+const author = orm.em.create(Author, {
+  name: 'Jon Snow',
+  email: 'snow@wall.st',
+});
+const book = orm.em.create(Book, {
+  title: 'My Life on The Wall',
+  author,
+});
+
+// Flush persists all tracked changes in a single transaction
+await orm.em.flush();
+```
+
+### Querying
+
+```typescript
+// Find with relations
+const authors = await orm.em.findAll(Author, {
+  populate: ['books'],
+  orderBy: { name: 'asc' },
+});
+
+// Type-safe QueryBuilder
+const qb = orm.em.createQueryBuilder(Author);
+const result = await qb
+  .select('*')
+  .where({ books: { title: { $like: '%Wall%' } } })
+  .getResult();
+```
+
+### Request Context
+
+In web applications, use `RequestContext` to isolate the identity map per request:
+
+```typescript
+const app = express();
+
+app.use((req, res, next) => {
+  RequestContext.create(orm.em, next);
+});
+```
+
+More info about `RequestContext` is described [here](https://mikro-orm.io/docs/identity-map/#request-context).
+
+## Unit of Work
+
+> Unit of Work maintains a list of objects (_entities_) affected by a business transaction
+> and coordinates the writing out of changes. [(Martin Fowler)](https://www.martinfowler.com/eaaCatalog/unitOfWork.html)
+
+When you call `em.flush()`, all computed changes are queried inside a database transaction. This means you can control transaction boundaries simply by making changes to your entities and calling `flush()` when ready.
+
+```typescript
+const author = await em.findOneOrFail(Author, 1, {
+  populate: ['books'],
+});
+author.name = 'Jon Snow II';
+author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
+author.books.add(orm.em.create(Book, { title: 'New Book', author }));
+
+// Flush computes change sets and executes them in a single transaction
+await em.flush();
+```
+
+The above flush will execute:
+
+```sql
+begin;
+update "author" set "name" = 'Jon Snow II' where "id" = 1;
+update "book"
+  set "title" = case
+    when ("id" = 1) then 'My Life on The Wall (2nd ed.)'
+    when ("id" = 2) then 'Another Book (2nd ed.)'
+    else "title" end
+  where "id" in (1, 2);
+insert into "book" ("title", "author_id") values ('New Book', 1);
+commit;
+```
+
+## Core Features
+
+- [Clean and Simple Entity Definition](https://mikro-orm.io/docs/defining-entities) — decorators, `EntitySchema`, or `defineEntity`
+- [Identity Map](https://mikro-orm.io/docs/identity-map) and [Unit of Work](https://mikro-orm.io/docs/unit-of-work) — automatic change tracking
+- [Entity References](https://mikro-orm.io/docs/entity-references) and [Collections](https://mikro-orm.io/docs/collections)
+- [QueryBuilder](https://mikro-orm.io/docs/query-builder) and [Kysely Integration](https://mikro-orm.io/docs/kysely)
+- [Transactions](https://mikro-orm.io/docs/transactions) and [Cascading](https://mikro-orm.io/docs/cascading)
+- [Populating Relations](https://mikro-orm.io/docs/populating-relations) and [Loading Strategies](https://mikro-orm.io/docs/loading-strategies)
+- [Filters](https://mikro-orm.io/docs/filters) and [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
+- [Schema Generator](https://mikro-orm.io/docs/schema-generator) and [Migrations](https://mikro-orm.io/docs/migrations)
+- [Entity Generator](https://mikro-orm.io/docs/entity-generator) and [Seeding](https://mikro-orm.io/docs/seeding)
+- [Embeddables](https://mikro-orm.io/docs/embeddables), [Custom Types](https://mikro-orm.io/docs/custom-types), and [Serialization](https://mikro-orm.io/docs/serializing)
+- [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
+- [Entity Constructors](https://mikro-orm.io/docs/entity-constructors) and [Property Validation](https://mikro-orm.io/docs/property-validation)
+- [Modelling Relationships](https://mikro-orm.io/docs/relationships) and [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
+
+## Documentation
+
+MikroORM documentation, included in this repo in the root directory, is built with [Docusaurus](https://docusaurus.io) and publicly hosted on GitHub Pages at https://mikro-orm.io.
+
+There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit messages (via `semantic-release`).
+
+## Example Integrations
+
+You can find example integrations for some popular frameworks in the [`mikro-orm-examples` repository](https://github.com/mikro-orm/mikro-orm-examples):
+
+### TypeScript Examples
+
+- [Express + MongoDB](https://github.com/mikro-orm/express-ts-example-app)
+- [Nest + MySQL](https://github.com/mikro-orm/nestjs-example-app)
+- [RealWorld example app (Nest + MySQL)](https://github.com/mikro-orm/nestjs-realworld-example-app)
+- [Koa + SQLite](https://github.com/mikro-orm/koa-ts-example-app)
+- [GraphQL + PostgreSQL](https://github.com/driescroons/mikro-orm-graphql-example)
+- [Inversify + PostgreSQL](https://github.com/PodaruDragos/inversify-example-app)
+- [NextJS + MySQL](https://github.com/jonahallibone/mikro-orm-nextjs)
+- [Accounts.js REST and GraphQL authentication + SQLite](https://github.com/darkbasic/mikro-orm-accounts-example)
+- [Nest + Shopify + PostgreSQL + GraphQL](https://github.com/Cloudshelf/Shopify_CSConnector)
+- [Elysia.js + libSQL + Bun](https://github.com/mikro-orm/elysia-bun-example-app)
+- [Electron.js + PostgreSQL](https://github.com/adnanlah/electron-mikro-orm-example-app)
+
+### JavaScript Examples
+
+- [Express + SQLite](https://github.com/mikro-orm/express-js-example-app)
+
+## Contributing
+
+Contributions, issues and feature requests are welcome. Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the process for submitting pull requests to us.
+
+## Authors
+
+**Martin Adámek**
+
+- Twitter: [@B4nan](https://twitter.com/B4nan)
+- Github: [@b4nan](https://github.com/b4nan)
+
+See also the list of contributors who [participated](https://github.com/mikro-orm/mikro-orm/contributors) in this project.
+
+## Show Your Support
+
+Please star this repository if this project helped you!
+
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
+## License
+
+Copyright © 2018-present [Martin Adámek](https://github.com/b4nan).
+
+This project is licensed under the MIT License - see the [LICENSE file](LICENSE) for details.

package/SqlJsConnection.d.ts

@@ -0,0 +1,23 @@
+import { BaseSqliteConnection, type Dictionary } from '@mikro-orm/sql';
+import { type Dialect } from 'kysely';
+import type { Routine, Transaction } from '@mikro-orm/core';
+import type { SqlJsNativeDatabase } from './typings.js';
+/** In-memory SQLite connection backed by sql.js (SQLite compiled to WebAssembly). */
+export declare class SqlJsConnection extends BaseSqliteConnection {
+    #private;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
+    createKyselyDialect(options: Dictionary): Dialect;
+    close(force?: boolean): Promise<void>;
+    /** @inheritDoc */
+    executeDump(dump: string): Promise<void>;
+    /**
+     * Returns the sql.js `Database` backing this connection, e.g. to persist it via `db.export()`.
+     * It is closed together with the ORM, so do not hold on to the returned handle across `orm.close()`.
+     */
+    getNativeClient(): Promise<SqlJsNativeDatabase>;
+    /** SQLite has no procedures; functions bridge via `bodyJs` registered as a UDF. */
+    callRoutine<T>(routine: Routine, args?: Record<string, unknown>, ctx?: Transaction): Promise<T>;
+    private validateAttachSupport;
+}

package/SqlJsConnection.js

@@ -0,0 +1,82 @@
+// the ambient declaration has to be pulled in explicitly, consumers compile our sources via the `exports` map
+// eslint-disable-next-line typescript/triple-slash-reference
+/// <reference path="./sql-js.d.ts" />
+import { BaseSqliteConnection } from '@mikro-orm/sql';
+import { SqliteDialect } from 'kysely';
+import initSqlJs from 'sql.js';
+import { SqlJsDatabase } from './SqlJsDatabase.js';
+// the ambient `sql.js` declaration is intentionally loose, our own types describe what we actually use
+const init = initSqlJs;
+/** In-memory SQLite connection backed by sql.js (SQLite compiled to WebAssembly). */
+export class SqlJsConnection extends BaseSqliteConnection {
+    #database;
+    // Routine name → registered `bodyJs` ref. Reference compare to detect HMR swaps and re-register.
+    #registeredRoutines = new Map();
+    async connect(options) {
+        this.validateAttachSupport();
+        await super.connect(options);
+    }
+    createKyselyDialect(options) {
+        const { sqlJs, data, ...config } = options;
+        return new SqliteDialect({
+            // sql.js loads its WASM module asynchronously, so the database can only be built inside the async factory
+            database: async () => {
+                const SQL = typeof sqlJs === 'function' ? await sqlJs() : (sqlJs ?? (await init(config)));
+                this.#database = new SQL.Database(data);
+                // fresh Database = fresh function table; clear cached registrations
+                this.#registeredRoutines.clear();
+                return new SqlJsDatabase(this.#database);
+            },
+            onCreateConnection: this.options.onCreateConnection ?? this.config.get('onCreateConnection'),
+        });
+    }
+    async close(force) {
+        await super.close(force);
+        // kysely already closed the sql.js database; drop it so a reconnect builds a new one
+        this.#database = undefined;
+    }
+    /** @inheritDoc */
+    async executeDump(dump) {
+        const db = await this.getNativeClient();
+        db.exec(dump);
+    }
+    /**
+     * Returns the sql.js `Database` backing this connection, e.g. to persist it via `db.export()`.
+     * It is closed together with the ORM, so do not hold on to the returned handle across `orm.close()`.
+     */
+    async getNativeClient() {
+        await this.ensureConnection();
+        return this.requireNativeClient(this.#database);
+    }
+    /** SQLite has no procedures; functions bridge via `bodyJs` registered as a UDF. */
+    async callRoutine(routine, args = {}, ctx) {
+        if (routine.type === 'procedure') {
+            throw new Error(`Stored procedures are not supported on SQLite. Routine ${routine.name} cannot be invoked here — define a separate code path for SQLite or call it only against a server-side database.`);
+        }
+        if (!routine.bodyJs) {
+            throw new Error(`Function ${routine.name} cannot be invoked on SQLite without a 'bodyJs' fallback. Add a JS implementation to the Routine declaration to enable cross-DB testing.`);
+        }
+        const db = await this.getNativeClient();
+        const fn = routine.bodyJs;
+        // Re-register on reference mismatch (HMR or a re-bound closure); sql.js replaces silently.
+        if (this.#registeredRoutines.get(routine.name) !== fn) {
+            const udf = (...positional) => {
+                const named = {};
+                routine.params.forEach((p, i) => {
+                    named[p.name] = positional[i];
+                });
+                return fn(named);
+            };
+            // sql.js derives the SQL arity from the callback's declared parameter count, which rest args report as 0
+            Object.defineProperty(udf, 'length', { value: routine.params.length });
+            db.create_function(routine.name, udf);
+            this.#registeredRoutines.set(routine.name, fn);
+        }
+        return this.callRoutineFunction(routine, args, ctx);
+    }
+    validateAttachSupport() {
+        if (this.config.get('attachDatabases')?.length) {
+            throw new Error('ATTACH DATABASE is not supported by the sql.js driver, as it has no filesystem access. Load the additional data into the single in-memory database instead.');
+        }
+    }
+}

package/SqlJsDatabase.d.ts

@@ -0,0 +1,9 @@
+import type { SqliteDatabase, SqliteStatement } from 'kysely';
+import type { SqlJsNativeDatabase } from './typings.js';
+/** Kysely compatible `SqliteDatabase` backed by an in-memory sql.js instance. */
+export declare class SqlJsDatabase implements SqliteDatabase {
+    #private;
+    constructor(db: SqlJsNativeDatabase);
+    prepare(sql: string): SqliteStatement;
+    close(): void;
+}

package/SqlJsDatabase.js

@@ -0,0 +1,84 @@
+/** sql.js has no bigint support and rejects `undefined`, so both need coercing first. */
+function coerceParams(parameters) {
+    return parameters.map(value => {
+        if (typeof value === 'bigint') {
+            // values beyond the safe integer range go in as strings, INTEGER column affinity converts them back
+            return Number.isSafeInteger(Number(value)) ? Number(value) : value.toString();
+        }
+        return (value ?? null);
+    });
+}
+/** sql.js rejects unbindable values by throwing plain strings, which would leave the driver exception without a message. */
+function toError(e) {
+    return typeof e === 'string' ? new Error(e) : e;
+}
+/** Wraps a sql.js statement in the better-sqlite3 shaped interface kysely expects. */
+class SqlJsStatementAdapter {
+    #db;
+    #stmt;
+    constructor(db, sql) {
+        this.#db = db;
+        this.#stmt = db.prepare(sql);
+        // sql.js consumes only the first statement and drops the rest silently, so reject the input like better-sqlite3 does
+        const tail = sql
+            .slice(this.#stmt.getSQL().length)
+            .replace(/--[^\n]*|\/\*[\s\S]*?\*\//g, '')
+            .replaceAll(';', '');
+        if (tail.trim()) {
+            this.#stmt.free();
+            throw new Error('The supplied SQL string contains more than one statement');
+        }
+    }
+    /** Only statements producing a result set have columns, which is what `reader` means for kysely. */
+    get reader() {
+        return this.#stmt.getColumnNames().length > 0;
+    }
+    all(parameters) {
+        return [...this.iterate(parameters)];
+    }
+    *iterate(parameters) {
+        const stmt = this.#stmt;
+        try {
+            stmt.bind(coerceParams(parameters));
+            while (stmt.step()) {
+                yield stmt.getAsObject();
+            }
+        }
+        catch (e) {
+            throw toError(e);
+        }
+        finally {
+            stmt.free();
+        }
+    }
+    run(parameters) {
+        const stmt = this.#stmt;
+        try {
+            stmt.bind(coerceParams(parameters));
+            stmt.step();
+        }
+        catch (e) {
+            throw toError(e);
+        }
+        finally {
+            stmt.free();
+        }
+        // sql.js exposes neither of these on the statement, they are database level functions
+        const changes = this.#db.getRowsModified();
+        const lastInsertRowid = Number(this.#db.exec('select last_insert_rowid()')[0].values[0][0]);
+        return { changes, lastInsertRowid };
+    }
+}
+/** Kysely compatible `SqliteDatabase` backed by an in-memory sql.js instance. */
+export class SqlJsDatabase {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    prepare(sql) {
+        return new SqlJsStatementAdapter(this.#db, sql);
+    }
+    close() {
+        this.#db.close();
+    }
+}

package/SqlJsDriver.d.ts

@@ -0,0 +1,10 @@
+import type { Configuration, Constructor } from '@mikro-orm/core';
+import { AbstractSqlDriver } from '@mikro-orm/sql';
+import { SqlJsConnection } from './SqlJsConnection.js';
+import { SqlJsMikroORM } from './SqlJsMikroORM.js';
+/** Database driver for in-memory SQLite via sql.js (WebAssembly). */
+export declare class SqlJsDriver extends AbstractSqlDriver<SqlJsConnection> {
+    constructor(config: Configuration);
+    /** @inheritDoc */
+    getORMClass(): Constructor<SqlJsMikroORM>;
+}

package/SqlJsDriver.js

@@ -0,0 +1,13 @@
+import { AbstractSqlDriver, SqlitePlatform } from '@mikro-orm/sql';
+import { SqlJsConnection } from './SqlJsConnection.js';
+import { SqlJsMikroORM } from './SqlJsMikroORM.js';
+/** Database driver for in-memory SQLite via sql.js (WebAssembly). */
+export class SqlJsDriver extends AbstractSqlDriver {
+    constructor(config) {
+        super(config, new SqlitePlatform(), SqlJsConnection, ['kysely', 'sql.js']);
+    }
+    /** @inheritDoc */
+    getORMClass() {
+        return SqlJsMikroORM;
+    }
+}

package/SqlJsMikroORM.d.ts

@@ -0,0 +1,20 @@
+import { type AnyEntity, type EntityClass, type EntitySchema, type MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { SqlMikroORM, type SqlEntityManager } from '@mikro-orm/sql';
+import { SqlJsDriver } from './SqlJsDriver.js';
+/** Configuration options for the sql.js driver. */
+export type SqlJsOptions<EM extends SqlEntityManager<SqlJsDriver> = SqlEntityManager<SqlJsDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<SqlJsDriver, EM, Entities>>;
+/** Creates a type-safe configuration object for the sql.js driver. */
+export declare function defineSqlJsConfig<EM extends SqlEntityManager<SqlJsDriver> = SqlEntityManager<SqlJsDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: SqlJsOptions<EM, Entities>): SqlJsOptions<EM, Entities>;
+/**
+ * @inheritDoc
+ */
+export declare class SqlJsMikroORM<EM extends SqlEntityManager<SqlJsDriver> = SqlEntityManager<SqlJsDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends SqlMikroORM<SqlJsDriver, EM, Entities> {
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = SqlJsDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
+    /**
+     * @inheritDoc
+     */
+    constructor(options: Partial<Options<SqlJsDriver, EM, Entities>>);
+}

package/SqlJsMikroORM.js

@@ -0,0 +1,25 @@
+import { defineConfig, } from '@mikro-orm/core';
+import { SqlMikroORM } from '@mikro-orm/sql';
+import { SqlJsDriver } from './SqlJsDriver.js';
+/** Creates a type-safe configuration object for the sql.js driver. */
+export function defineSqlJsConfig(options) {
+    // sql.js is always in-memory; satisfy MikroORM's `dbName` validation without forcing every user to spell it out.
+    return defineConfig({ driver: SqlJsDriver, dbName: ':memory:', ...options });
+}
+/**
+ * @inheritDoc
+ */
+export class SqlJsMikroORM extends SqlMikroORM {
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(defineSqlJsConfig(options));
+    }
+    /**
+     * @inheritDoc
+     */
+    constructor(options) {
+        super(defineSqlJsConfig(options));
+    }
+}

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from '@mikro-orm/sql';
+export * from './SqlJsConnection.js';
+export * from './SqlJsDriver.js';
+export type * from './typings.js';
+export { SqlJsMikroORM as MikroORM, type SqlJsOptions as Options, defineSqlJsConfig as defineConfig, } from './SqlJsMikroORM.js';
+import { type AbstractSqlDriver, SqlEntityManager } from '@mikro-orm/sql';
+import type { SqlJsDriver } from './SqlJsDriver.js';
+export type EntityManager<Driver extends AbstractSqlDriver = SqlJsDriver> = SqlEntityManager<Driver>;
+export declare const EntityManager: typeof SqlEntityManager;

package/index.js

@@ -0,0 +1,6 @@
+export * from '@mikro-orm/sql';
+export * from './SqlJsConnection.js';
+export * from './SqlJsDriver.js';
+export { SqlJsMikroORM as MikroORM, defineSqlJsConfig as defineConfig, } from './SqlJsMikroORM.js';
+import { SqlEntityManager } from '@mikro-orm/sql';
+export const EntityManager = SqlEntityManager;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@mikro-orm/sql-js",
+  "version": "7.2.0-dev.22",
+  "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
+  "keywords": [
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "orm",
+    "postgresql",
+    "sql.js",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "unit-of-work",
+    "wasm"
+  ],
+  "homepage": "https://mikro-orm.io",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "yarn compile && yarn copy",
+    "clean": "yarn run -T rimraf ./dist ./tsconfig.build.tsbuildinfo",
+    "compile": "yarn run -T tsc -p tsconfig.build.json",
+    "copy": "node ../../scripts/copy.mjs"
+  },
+  "dependencies": {
+    "@mikro-orm/sql": "7.2.0-dev.22",
+    "kysely": "0.29.5",
+    "sql.js": "1.14.2"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "7.2.0-dev.22"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
+  }
+}

package/typings.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Minimal subset of the sql.js surface this driver relies on. Declared locally on purpose —
+ * `@types/sql.js` references `@types/emscripten`, which needs DOM globals and breaks every
+ * consumer compiling without `lib: dom` or `skipLibCheck`.
+ */
+/** Column value sql.js can bind and return natively. */
+export type SqlValue = number | string | Uint8Array | null;
+/** Prepared statement handle, as returned by `db.prepare()`. */
+export interface SqlJsStatement {
+    bind(params?: SqlValue[]): boolean;
+    /** The single statement sql.js actually consumed from the string passed to `db.prepare()`. */
+    getSQL(): string;
+    step(): boolean;
+    getAsObject(): Record<string, SqlValue>;
+    getColumnNames(): string[];
+    free(): boolean;
+}
+/** The native sql.js `Database` instance backing a connection. */
+export interface SqlJsNativeDatabase {
+    prepare(sql: string): SqlJsStatement;
+    exec(sql: string): {
+        columns: string[];
+        values: SqlValue[][];
+    }[];
+    create_function(name: string, fn: (...args: SqlValue[]) => SqlValue | undefined): void;
+    getRowsModified(): number;
+    export(): Uint8Array;
+    close(): void;
+}
+/** The module `initSqlJs()` resolves with. */
+export interface SqlJsStatic {
+    Database: new (data?: ArrayLike<number> | null) => SqlJsNativeDatabase;
+}
+/** Options accepted by `initSqlJs()`; an open bag, as everything is forwarded to the emscripten module. */
+export interface SqlJsConfig {
+    locateFile?(file: string, scriptDirectory: string): string;
+    wasmBinary?: ArrayBuffer | Uint8Array;
+    [key: string]: unknown;
+}
+/** Signature of the `sql.js` default export. */
+export type InitSqlJs = (config?: SqlJsConfig) => Promise<SqlJsStatic>;

package/typings.js

@@ -0,0 +1,6 @@
+/**
+ * Minimal subset of the sql.js surface this driver relies on. Declared locally on purpose —
+ * `@types/sql.js` references `@types/emscripten`, which needs DOM globals and breaks every
+ * consumer compiling without `lib: dom` or `skipLibCheck`.
+ */
+export {};