@mikro-orm/pglite 7.0.18-dev.0

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/PgliteConnection.d.ts

@@ -0,0 +1,10 @@
+import { PGliteDialect } from 'kysely';
+import { AbstractSqlConnection, type Dictionary } from '@mikro-orm/sql';
+/** PostgreSQL-in-WASM database connection using `@electric-sql/pglite`. */
+export declare class PgliteConnection extends AbstractSqlConnection {
+    #private;
+    createKyselyDialect(overrides: Dictionary): PGliteDialect;
+    close(force?: boolean): Promise<void>;
+    /** PGlite supports multi-statement scripts via `exec()`, which is what schema dumps need. */
+    executeDump(source: string): Promise<void>;
+}

package/PgliteConnection.js

@@ -0,0 +1,77 @@
+import { PGlite } from '@electric-sql/pglite';
+import { PGliteDialect } from 'kysely';
+import array from 'postgres-array';
+import { AbstractSqlConnection, createPostgreSqlTypeParsers } from '@mikro-orm/sql';
+const isInMemoryDataDir = (dataDir) => !dataDir || dataDir === 'memory://' || dataDir.startsWith('memory:');
+/** PostgreSQL-in-WASM database connection using `@electric-sql/pglite`. */
+export class PgliteConnection extends AbstractSqlConnection {
+    // Stored as a Promise so `createKyselyDialect` can stay synchronous (else
+    // `getClient()` would throw "Current driver requires async initialization")
+    // while `executeDump` and the kysely dialect both `await` the same instance.
+    #pglite;
+    #neuterClose = false;
+    #ownsPglite = true;
+    createKyselyDialect(overrides) {
+        const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
+        const options = (overrides ?? {});
+        const { pglite: userPglite, ...pgliteOptions } = options;
+        const dataDir = options.dataDir ?? this.config.get('dbName');
+        const parsers = { ...createPostgreSqlTypeParsers(s => array.parse(s)), ...options.parsers };
+        this.#ownsPglite = !userPglite;
+        // Skip `pglite.close()` (called by kysely's `PGliteDriver.destroy()`) when:
+        //   - the user owns the instance (closing it is their responsibility), or
+        //   - we hold an in-memory DB whose data would otherwise be lost on
+        //     reconnect (e.g. test harnesses that drive `orm.close()` + `orm.connect()`).
+        // For file/IDB-backed instances we let kysely close so file handles / IDB
+        // connections are released; we drop our cached promise in `close()` below
+        // so the next dialect-construction rebuilds the PGlite instance.
+        this.#neuterClose = !this.#ownsPglite || isInMemoryDataDir(dataDir);
+        if (!this.#pglite) {
+            if (userPglite) {
+                this.#pglite = typeof userPglite === 'function' ? Promise.resolve(userPglite()) : Promise.resolve(userPglite);
+            }
+            else {
+                this.#pglite = PGlite.create({ ...pgliteOptions, dataDir, parsers });
+            }
+        }
+        if (this.#neuterClose) {
+            // Hand kysely a delegating wrapper rather than mutating the underlying
+            // instance — proxies can't pierce PGlite's private fields, and patching
+            // `close` directly would orphan a user-supplied PGlite (its real `close`
+            // would stay neutered after `orm.close()`). Each method call hits the
+            // original `p`, so `#private` fields stay reachable.
+            const sharedPglitePromise = this.#pglite.then(p => ({
+                query: p.query.bind(p),
+                transaction: p.transaction.bind(p),
+                close: () => Promise.resolve(),
+                get closed() {
+                    return p.closed;
+                },
+                get ready() {
+                    return p.ready;
+                },
+                // `waitReady` is a stable Promise on the underlying instance — capture it
+                // directly so coverage doesn't hinge on `kysely` actually awaiting it (which
+                // only happens in the WASM-not-yet-loaded transient window).
+                waitReady: p.waitReady,
+            }));
+            return new PGliteDialect({ pglite: () => sharedPglitePromise, onCreateConnection });
+        }
+        return new PGliteDialect({ pglite: () => this.#pglite, onCreateConnection });
+    }
+    async close(force) {
+        await super.close(force);
+        // Persistent backings (file/IDB) we own get really closed by kysely — drop
+        // the cached promise so a subsequent reconnect rebuilds a fresh instance
+        // (which then re-reads the persisted data from disk / IDB).
+        if (this.#ownsPglite && !this.#neuterClose) {
+            this.#pglite = undefined;
+        }
+    }
+    /** PGlite supports multi-statement scripts via `exec()`, which is what schema dumps need. */
+    async executeDump(source) {
+        await this.ensureConnection();
+        const pglite = await this.#pglite;
+        await pglite.exec(source);
+    }
+}

package/PgliteDriver.d.ts

@@ -0,0 +1,12 @@
+import { type Configuration, type Constructor, EntityManagerType } from '@mikro-orm/core';
+import { AbstractSqlDriver, BasePostgreSqlEntityManager } from '@mikro-orm/sql';
+import { PgliteConnection } from './PgliteConnection.js';
+import { PgliteMikroORM } from './PgliteMikroORM.js';
+/** Database driver for PGlite (PostgreSQL in WASM). */
+export declare class PgliteDriver extends AbstractSqlDriver<PgliteConnection> {
+    [EntityManagerType]: BasePostgreSqlEntityManager<this>;
+    constructor(config: Configuration);
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
+    /** @inheritDoc */
+    getORMClass(): Constructor<PgliteMikroORM>;
+}

package/PgliteDriver.js

@@ -0,0 +1,20 @@
+import { EntityManagerType } from '@mikro-orm/core';
+import { AbstractSqlDriver, BasePostgreSqlEntityManager } from '@mikro-orm/sql';
+import { PgliteConnection } from './PgliteConnection.js';
+import { PglitePlatform } from './PglitePlatform.js';
+import { PgliteMikroORM } from './PgliteMikroORM.js';
+/** Database driver for PGlite (PostgreSQL in WASM). */
+export class PgliteDriver extends AbstractSqlDriver {
+    [EntityManagerType];
+    constructor(config) {
+        super(config, new PglitePlatform(), PgliteConnection, ['kysely', '@electric-sql/pglite']);
+    }
+    createEntityManager(useContext) {
+        const EntityManagerClass = this.config.get('entityManager', BasePostgreSqlEntityManager);
+        return new EntityManagerClass(this.config, this, this.metadata, useContext);
+    }
+    /** @inheritDoc */
+    getORMClass() {
+        return PgliteMikroORM;
+    }
+}

package/PgliteMikroORM.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 BasePostgreSqlEntityManager } from '@mikro-orm/sql';
+import { PgliteDriver } from './PgliteDriver.js';
+/** Configuration options for the PGlite driver. */
+export type PgliteOptions<EM extends BasePostgreSqlEntityManager<PgliteDriver> = BasePostgreSqlEntityManager<PgliteDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<PgliteDriver, EM, Entities>>;
+/** Creates a type-safe configuration object for the PGlite driver. */
+export declare function definePgliteConfig<EM extends BasePostgreSqlEntityManager<PgliteDriver> = BasePostgreSqlEntityManager<PgliteDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: PgliteOptions<EM, Entities>): PgliteOptions<EM, Entities>;
+/**
+ * @inheritDoc
+ */
+export declare class PgliteMikroORM<EM extends BasePostgreSqlEntityManager<PgliteDriver> = BasePostgreSqlEntityManager<PgliteDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends SqlMikroORM<PgliteDriver, EM, Entities> {
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = PgliteDriver, 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<PgliteDriver, EM, Entities>>);
+}

package/PgliteMikroORM.js

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

package/PglitePlatform.d.ts

@@ -0,0 +1,16 @@
+import { type IPostgresInterval } from 'postgres-interval';
+import { BasePostgreSqlPlatform } from '@mikro-orm/sql';
+import { PgliteSchemaHelper } from './PgliteSchemaHelper.js';
+/** Platform implementation for PGlite (PostgreSQL in WASM, single-database). */
+export declare class PglitePlatform extends BasePostgreSqlPlatform {
+    protected readonly schemaHelper: PgliteSchemaHelper;
+    /** PGlite uses the extended query protocol — one statement per `query()` call. */
+    supportsMultipleStatements(): boolean;
+    convertIntervalToJSValue(value: string): unknown;
+    convertIntervalToDatabaseValue(value: IPostgresInterval): unknown;
+    unmarshallArray(value: string): string[];
+    /**
+     * @inheritDoc
+     */
+    parseDate(value: string | number): Date;
+}

package/PglitePlatform.js

@@ -0,0 +1,45 @@
+import array from 'postgres-array';
+import parseDate from 'postgres-date';
+import PostgresInterval from 'postgres-interval';
+import { BasePostgreSqlPlatform, Utils } from '@mikro-orm/sql';
+import { PgliteSchemaHelper } from './PgliteSchemaHelper.js';
+/** Platform implementation for PGlite (PostgreSQL in WASM, single-database). */
+export class PglitePlatform extends BasePostgreSqlPlatform {
+    schemaHelper = new PgliteSchemaHelper(this);
+    /** PGlite uses the extended query protocol — one statement per `query()` call. */
+    supportsMultipleStatements() {
+        return false;
+    }
+    convertIntervalToJSValue(value) {
+        return PostgresInterval(value);
+    }
+    convertIntervalToDatabaseValue(value) {
+        if (Utils.isObject(value) && 'toPostgres' in value && typeof value.toPostgres === 'function') {
+            return value.toPostgres();
+        }
+        return value;
+    }
+    unmarshallArray(value) {
+        return array.parse(value);
+    }
+    /**
+     * @inheritDoc
+     */
+    parseDate(value) {
+        // postgres-date returns `null` for a JS ISO string which has the `T` separator
+        if (typeof value === 'string' && value.charAt(10) === 'T') {
+            return new Date(value);
+        }
+        /* v8 ignore next */
+        if (typeof value === 'number') {
+            return new Date(value);
+        }
+        // @ts-ignore fix wrong type resolution during build
+        const parsed = parseDate(value);
+        /* v8 ignore next */
+        if (parsed === null) {
+            return value;
+        }
+        return parsed;
+    }
+}

package/PgliteSchemaHelper.d.ts

@@ -0,0 +1,12 @@
+import type { Connection } from '@mikro-orm/core';
+import { PostgreSqlSchemaHelper } from '@mikro-orm/sql';
+/**
+ * PGlite is a single-database engine — there is no management catalog and no
+ * `CREATE DATABASE`. Override the relevant lifecycle hooks to no-ops.
+ */
+export declare class PgliteSchemaHelper extends PostgreSqlSchemaHelper {
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(): string;
+    getDropDatabaseSQL(): string;
+    databaseExists(_connection: Connection, _name: string): Promise<boolean>;
+}

package/PgliteSchemaHelper.js

@@ -0,0 +1,19 @@
+import { PostgreSqlSchemaHelper } from '@mikro-orm/sql';
+/**
+ * PGlite is a single-database engine — there is no management catalog and no
+ * `CREATE DATABASE`. Override the relevant lifecycle hooks to no-ops.
+ */
+export class PgliteSchemaHelper extends PostgreSqlSchemaHelper {
+    getManagementDbName() {
+        return '';
+    }
+    getCreateDatabaseSQL() {
+        return '';
+    }
+    getDropDatabaseSQL() {
+        return '';
+    }
+    async databaseExists(_connection, _name) {
+        return true;
+    }
+}

package/README.md

@@ -0,0 +1,226 @@
+<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/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/index.d.ts

@@ -0,0 +1,7 @@
+export * from '@mikro-orm/sql';
+export * from './PgliteConnection.js';
+export * from './PgliteDriver.js';
+export * from './PglitePlatform.js';
+export * from './PgliteSchemaHelper.js';
+export { PgliteMikroORM as MikroORM, type PgliteOptions as Options, definePgliteConfig as defineConfig, } from './PgliteMikroORM.js';
+export { raw } from './raw.js';

package/index.js

@@ -0,0 +1,7 @@
+export * from '@mikro-orm/sql';
+export * from './PgliteConnection.js';
+export * from './PgliteDriver.js';
+export * from './PglitePlatform.js';
+export * from './PgliteSchemaHelper.js';
+export { PgliteMikroORM as MikroORM, definePgliteConfig as defineConfig, } from './PgliteMikroORM.js';
+export { raw } from './raw.js';

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@mikro-orm/pglite",
+  "version": "7.0.18-dev.0",
+  "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",
+    "pglite",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "unit-of-work"
+  ],
+  "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": {
+    "@electric-sql/pglite": "0.4.4",
+    "@mikro-orm/sql": "7.0.18-dev.0",
+    "kysely": "0.29.2",
+    "postgres-array": "3.0.4",
+    "postgres-date": "2.1.0",
+    "postgres-interval": "4.0.2"
+  },
+  "devDependencies": {
+    "@mikro-orm/core": "^7.0.17"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "7.0.18-dev.0"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
+  }
+}

package/raw.d.ts

@@ -0,0 +1,67 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/sql';
+import type { SelectQueryBuilder as KyselySelectQueryBuilder } from 'kysely';
+/** @internal Type for QueryBuilder instances passed to raw() - uses toRaw to distinguish from Kysely QueryBuilder */
+type QueryBuilderLike = {
+    toQuery(): {
+        sql: string;
+        params: readonly unknown[];
+    };
+    toRaw(): RawQueryFragment;
+};
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: QueryBuilderLike | KyselySelectQueryBuilder<any, any, any> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export {};

package/raw.js

@@ -0,0 +1,64 @@
+import { raw as raw_, Utils, } from '@mikro-orm/sql';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function raw(sql, params) {
+    if (Utils.isObject(sql) && 'compile' in sql) {
+        const query = sql.compile();
+        const processed = query.sql.replaceAll(/\$\d+/g, '?');
+        return raw_(processed, query.parameters);
+    }
+    return raw_(sql, params);
+}