neoorm 0.8.1 → 0.8.2

package/docs/relations.md

@@ -6,13 +6,13 @@
 
 | Relation kind | Operations |
 |---------------|------------|
-| **To-one** (outgoing FK) | `connect`, `create`, `disconnect` (nullable FK only) |
+| **To-one** (outgoing FK) | `connect`, `connectOrCreate`, `create`, `disconnect` (nullable FK only) |
 | **One-to-many** (inverse) | `create`, `connect`, `disconnect`, `set`, `delete` |
 | **Many-to-many** | `connect`, `connectOrCreate`, `disconnect`, `set`, `delete` |
 
-`connect`, `set`, `disconnect`, and `delete` identify related rows by the **target table's scalar primary key** (`{ id: ... }` when the PK is `id`, `{ userId: ... }` when it is `userId`). Composite-PK connect is not supported.
+`connect`, `set`, `disconnect`, and `delete` identify related rows by the **target table's primary key**: `{ id: ... }` or `{ userId: ... }` for a scalar PK, or an object with **every** PK column for a composite key. A single-column `fk()` still stores one referenced value; a composite `foreignKey()` extra assigns **each** local column from the matching target field (never a concatenated PK string).
 
-A relation field must be a **pure write bag**: every key is one of those operations. Mixing a write op with extra fields (`{ create: { name: "A" }, foo: 1 }`), passing a scalar, or passing `{}` throws `invalid_nested_write` — the parent row is not written.
+A relation field must be a **pure write bag**: every key is one of those operations. Mixing a write op with extra fields (`{ create: { name: "A" }, foo: 1 }`), passing a scalar, or passing `{}` throws `invalid_nested_write` — the parent row is not written. To-one `connectOrCreate` cannot be mixed with `connect` or `create`.
 
 ## Examples
 
@@ -21,7 +21,22 @@ A relation field must be a **pure write bag**: every key is one of those operati
 ```ts
 await db.posts.update({
   where: { id: postId },
-  data: { author: { connect: { id: userId } } },
+  data: {
+    author: { connect: { id: userId } },
+    // or create the author if missing:
+    // author: { connectOrCreate: { where: { email }, create: { email, password } } },
+  },
+});
+```
+
+Composite primary key:
+
+```ts
+await db.orders.update({
+  where: { id: orderId },
+  data: {
+    lines: { connect: [{ tenantId: "acme", lineNo: 1 }] },
+  },
 });
 ```
 

package/docs/schema.md

@@ -1,6 +1,6 @@
 # Schema DSL
 
-NeoOrm **0.8.0** uses accessor-based identity: schema keys, `fk("users")`, `many("tags")`, and `through: "postTags"` all refer to **accessors**, not raw SQL names. `schemaToManifest` resolves accessors to SQL before migrations and the typed client are generated.
+NeoOrm **0.8.0** and later uses accessor-based identity: schema keys, `fk("users")`, `many("tags")`, and `through: "postTags"` all refer to **accessors**, not raw SQL names. `schemaToManifest` resolves accessors to SQL before migrations and the typed client are generated.
 
 ## Tables and accessors
 
@@ -48,10 +48,21 @@ Column field names use camelCase in TypeScript. By default SQL column names are
 | `decimal()` / `numeric()` | `NUMERIC` | `string \| null` | Use strings to avoid float loss |
 | `enumType(["a", "b"])` | mode-dependent | union literals | See [Enum columns](#enum-columns) |
 | `bytea()` | `BYTEA` | `Buffer \| null` | |
-| `textArray()` / `intArray()` | arrays | arrays \| null | |
+| `textArray()` / `intArray()` | arrays | arrays \| null | JSON on SQLite/MySQL |
+| `uuidArray()` | `UUID[]` | `string[] \| null` | JSON on SQLite/MySQL |
+| `enumArray(["a", "b"])` | `TEXT[]` or `name[]` | union arrays \| null | Same enum storage mode as `enumType`; JSON on SQLite/MySQL |
+| `real()` / `float()` | `REAL` | `number \| null` | 32-bit. Prisma `Float` is `double()`. MySQL `FLOAT`, SQLite `REAL` |
+| `double()` | `DOUBLE PRECISION` | `number \| null` | MySQL `DOUBLE`, SQLite `REAL` |
+| `date()` | `DATE` | `string \| null` | `YYYY-MM-DD`, not `Date`. SQLite `TEXT`, MySQL `DATE` |
+| `time()` | `TIME` | `string \| null` | SQLite `TEXT`, MySQL `TIME` |
+| `interval()` | `INTERVAL` | `string \| null` | SQLite `TEXT`; rejected on MySQL/MariaDB |
+| `inet()` / `cidr()` | `INET` / `CIDR` | `string \| null` | SQLite `TEXT`; rejected on MySQL/MariaDB |
+| `xml()` | `XML` | `string \| null` | MySQL `LONGTEXT`, SQLite `TEXT` |
+| `money()` | `MONEY` | `string \| null` | MySQL `DECIMAL(19,4)`, SQLite `TEXT` |
+| `int4Range()` / `int8Range()` / `numRange()` / `tsRange()` / `tstzRange()` / `dateRange()` | matching PG ranges | `string \| null` | PostgreSQL only (rejected on SQLite and MySQL/MariaDB) |
 | `citext()` | `CITEXT` | `string \| null` | Requires `citext` extension |
 
-All column builders support `.notNull()`, `.unique()`, `.default(value)`, `.primary()`, `.map(name)`, `.hidden()`, `.index()`, and `.check("sql expression")`. Text columns add `.maxLength()`, `.minLength()`, `.notEmpty()`, `.email()`, and `.url()`. Numeric columns (`int`, `bigint`, `serial`, `decimal`) add `.min()`, `.max()`, and `.positive()`.
+All column builders support `.notNull()`, `.unique()`, `.default(value)`, `.primary()`, `.map(name)`, `.hidden()`, `.index()`, and `.check("sql expression")`. Text columns add `.maxLength()`, `.minLength()`, `.notEmpty()`, `.email()`, and `.url()`. Numeric columns (`int`, `bigint`, `serial`, `decimal`, `real`, `double`) add `.min()`, `.max()`, and `.positive()`.
 
 `.hidden()` marks a column as sensitive. It is omitted from default query output on the root table and on nested `with` includes. Pass `includeHidden: true` when the app needs the value (for example password verification on login). Use `.strip()` to remove any remaining sensitive fields before JSON responses.
 
@@ -100,7 +111,9 @@ Fluent modifiers (no options bag):
 |--------|--------|
 | `.as("author")` | override relation name on this table (default: strip `Id` from column name) |
 | `.inverse("articles")` | override relation name on the target table (rare — see defaults below) |
-| `.onDelete("cascade" \| "restrict" \| "set null" \| "no action")` | FK action |
+| `.onDelete("cascade" \| "restrict" \| "set null" \| "no action")` | FK `ON DELETE` |
+| `.onUpdate("cascade" \| "restrict" \| "set null" \| "no action")` | FK `ON UPDATE` |
+| `.deferrable("immediate" \| "deferred")` | `DEFERRABLE` (Postgres and SQLite; rejected on MySQL/MariaDB) |
 | `.notNull()` | `NOT NULL` |
 | `.unique()` | `UNIQUE` — unique FKs infer a **singular** inverse (`profiles.userId` → `users.profile`) |
 | `.primary()` | part of composite PK |
@@ -123,6 +136,39 @@ postTags: table("post_tags", {
 
 Multiple `.primary()` columns infer a composite key. `primaryKey(t.colA, t.colB)` in extras is optional when you want to name the key without marking every column.
 
+### Composite foreign keys
+
+Use table extras `foreignKey()` when several local columns form one constraint (and one relation). Do not also mark those columns `fk()`.
+
+```ts
+orders: table(
+  {
+    id: id(),
+    tenantId: text().notNull(),
+    userId: text().notNull(),
+  },
+  (t) => [
+    foreignKey(t.tenantId, t.userId)
+      .references("users", "tenantId", "id")
+      .as("user")
+      .inverse("orders")
+      .onDelete("cascade")
+      .onUpdate("cascade"),
+  ],
+),
+```
+
+The target column list must match a primary key or unique index. `.as()` and `.inverse()` are required. Connect still uses the target table's full primary key:
+
+```ts
+await db.orders.create({
+  data: {
+    tenantId: "acme",
+    user: { connect: { tenantId: "acme", id: userId } },
+  },
+});
+```
+
 ### Self-relations
 
 ```ts
@@ -148,7 +194,7 @@ export const schema = defineSchema({
 
 ## Column checks
 
-Use `.check("sql expression")` for custom CHECK constraints, or the typed helpers below. Helpers compile to database CHECK constraints (and `VARCHAR(n)` for text length on Postgres). They are not runtime validators by themselves. With [`generate.zod`](zod.md) or [`generate.typebox`](typebox.md), the same helpers are copied into generated validation schemas at your API boundary.
+Use `.check("sql expression")` for custom CHECK constraints, or the typed helpers below. Helpers compile to database CHECK constraints (and `VARCHAR(n)` for text length on Postgres). They are not runtime validators by themselves. With [`generate.zod`](zod.md), [`generate.typebox`](typebox.md), or [`generate.elysia`](elysia.md), the same helpers are copied into generated validation schemas at your API boundary.
 
 ### Typed constraint helpers
 
@@ -172,7 +218,7 @@ views: int().notNull().min(0)
 price: decimal({ precision: 10, scale: 2 }).notNull().positive()
 ```
 
-`.email()` and `.url()` are validation-only: they do not emit a SQL CHECK. With [`generate.zod`](zod.md) or [`generate.typebox`](typebox.md), columns named `email` or ending in `Email` (`contactEmail`) become email-format strings, and columns named `url` or ending in `Url` (`avatarUrl`) become URL-format strings. You can also mark any `text` / `citext` column with `.email()` or `.url()`. Foreign keys follow the **referenced** column (`authorEmail` pointing at a uuid PK stays a uuid).
+`.email()` and `.url()` are validation-only: they do not emit a SQL CHECK. With [`generate.zod`](zod.md), [`generate.typebox`](typebox.md), or [`generate.elysia`](elysia.md), columns named `email` or ending in `Email` (`contactEmail`) become email-format strings, and columns named `url` or ending in `Url` (`avatarUrl`) become URL-format strings. You can also mark any `text` / `citext` column with `.email()` or `.url()`. Foreign keys follow the **referenced** column (`authorEmail` pointing at a uuid PK stays a uuid).
 
 `citext` length helpers use CHECK only (no `VARCHAR`). NULL still bypasses CHECK — pair `.notEmpty()` with `.notNull()` to reject empty strings.
 
@@ -200,7 +246,24 @@ posts: table(
 ),
 ```
 
-Helpers: `unique(...cols)`, `index(...cols)`, `primaryKey(...cols)`. `unique()` and `index()` both support `.where()` for partial indexes.
+Helpers: `unique(...cols)`, `index(...cols)`, `primaryKey(...cols)`, `expr("sql")`. `unique()` and `index()` support `.using()`, `.ops()`, and `.where()` for partial indexes.
+
+### Index methods and expressions
+
+```ts
+(t) => [
+  index(t.tags).using("gin"),
+  index(t.metadata).using("gin").ops("jsonb_path_ops"),
+  index(t.location).using("gist"),
+  index(t.createdAt).using("brin"),
+  unique(expr("lower(email)")),
+  index(t.authorId, expr("date_trunc('day', created_at)")),
+],
+```
+
+Default method is btree (`USING btree` is omitted in SQL). Postgres also emits `gin`, `gist`, `brin`, and `hash`. SQLite allows expression keys and partial `WHERE`, but not those access methods. MySQL/MariaDB allow `USING HASH` and functional `(expr)` keys; they reject GIN/GiST/BRIN and partial `WHERE`.
+
+`unique()` cannot use `gin` / `gist` / `brin`. Expression unique indexes are not `findUnique` / `upsert` targets.
 
 ### Partial indexes
 
@@ -211,7 +274,7 @@ Helpers: `unique(...cols)`, `index(...cols)`, `primaryKey(...cols)`. `unique()`
 ],
 ```
 
-Equality map of column refs → values; compiled to `WHERE "published" = true` (or `= 1` on SQLite). Partial uniques emit as `CREATE UNIQUE INDEX ... WHERE ...`, not table-level `UNIQUE (...)`. They are not usable as `findUnique` / `upsert` targets.
+Equality map of column refs → values; compiled to `WHERE "published" = true` (or `= 1` on SQLite). Partial uniques emit as `CREATE UNIQUE INDEX ... WHERE ...`, not table-level `UNIQUE (...)`. They are valid `findUnique` / `upsert` / `findOrCreate` targets: `where` uses the indexed columns, and the index predicate is applied automatically (`AND` on lookups, `ON CONFLICT (…) WHERE …` on Postgres and SQLite).
 
 ## Many-to-many
 
@@ -282,7 +345,7 @@ status: enumType(["draft", "published", "archived"])
   .default("draft"),
 ```
 
-`datasource.enum` in config: `check` (default), `union`, or `native` (PostgreSQL only).
+`datasource.enum` in config: `check` (default), `union`, or `native` (PostgreSQL `CREATE TYPE` / MySQL and MariaDB column `ENUM`).
 
 ## PostgreSQL extensions
 
@@ -297,4 +360,4 @@ Column type plugins still register required extensions automatically.
 
 ## SQLite type mapping
 
-Same DSL; see [SQLite](sqlite.md) for storage types and limitations.
+Same DSL; see [SQLite](sqlite.md), [MySQL](mysql.md), and [MariaDB](mariadb.md) for storage types and limitations.

package/docs/sqlite.md

@@ -103,9 +103,11 @@ bunx neoorm migrate reset --force
 
 | Schema builder | SQLite storage |
 |----------------|----------------|
-| `id`, `text`, `uuid`, `json`, `jsonb`, `decimal`, `textArray`, `intArray`, `citext`, `enumType` | `TEXT` |
+| `id`, `text`, `uuid`, `json`, `jsonb`, `decimal`, `textArray`, `intArray`, `uuidArray`, `enumArray`, `citext`, `enumType`, `date`, `time`, `interval`, `inet`, `cidr`, `xml`, `money` | `TEXT` |
 | `int`, `serial` | `INTEGER` |
+| `real`, `double` | `REAL` |
 | `bigint` | `TEXT` |
+| `int4Range` … `dateRange` | rejected at schema compile |
 | `serial().primary()` | `INTEGER PRIMARY KEY AUTOINCREMENT` |
 | `bool` | `BOOLEAN` (stored as 0/1) |
 | `timestamp` | `TEXT` (ISO-8601) |
@@ -118,9 +120,11 @@ bunx neoorm migrate reset --force
 
 | Feature | PostgreSQL | SQLite |
 |---------|-----------|--------|
-| `distinct` (`DISTINCT ON`) | supported | throws `distinct is not supported on SQLite` |
+| `distinct` (`DISTINCT ON`) | supported | `ROW_NUMBER()` per distinct columns (same `orderBy` prefix rule) |
+| `search` | POSIX `~` / `~*` | JavaScript `RegExp` via `REGEXP` / `regexp_i` |
 | `datasource.schema` | multi-schema | not applicable |
 | `enum: "native"` | `CREATE TYPE ... AS ENUM` | not applicable (TEXT + CHECK) |
+| range types | supported | rejected at schema compile |
 | transaction options (`readOnly`, `isolationLevel`) | `BEGIN READ ONLY` / `ISOLATION LEVEL` | `readOnly` → `PRAGMA query_only`; `RepeatableRead`/`Serializable` → `BEGIN IMMEDIATE`; other isolation → `BEGIN` |
 | JSON operators | `@>`, `?`, `#>` | `json_patch` / `json_each` / `json_extract` |
 

package/docs/typebox.md

@@ -1,10 +1,10 @@
 # TypeBox schemas
 
-`neoorm generate` can print Select, Create, and Update **scalar** TypeBox schemas next to the typed client. Codegen maps your schema to a validator-neutral IR first; TypeBox is the second printer (alongside [Zod](zod.md)).
+`neoorm generate` can print Select, Create, and Update **scalar** TypeBox schemas next to the typed client. Codegen maps your schema to a validator-neutral IR first; TypeBox 1.x is one printer (alongside [Zod](zod.md) and [Elysia `t`](elysia.md)).
 
 Generated schemas match the TypeScript shapes of row / insert / update scalars — not nested relation writes (`connect`, `create`, `set`). Those stay TypeScript-only.
 
-Schemas target **TypeBox 1.x** (`typebox` on npm), not `@sinclair/typebox` 0.x.
+Schemas target **TypeBox 1.x** (`typebox` on npm), not `@sinclair/typebox` 0.x. For Elysia 1.x route `body:`, use [`generate.elysia`](elysia.md) instead.
 
 ## Enable
 
@@ -40,7 +40,7 @@ Disable `generate.typebox` and generate again to remove `typebox.ts`.
 
 `typebox` is an optional peer of NeoOrm. The generated file imports `typebox` directly; NeoOrm does not bundle it. If `generate.typebox` is on and `typebox` is not installed, `neoorm generate` still writes `typebox.ts` and prints a warning (`bun add typebox`).
 
-You can enable Zod and TypeBox together. When both are on, `client.ts` keeps Zod as a flat `export *` and re-exports TypeBox as `export * as typebox from "./typebox.js"` so names do not collide. Import TypeBox from `./typebox.js` (or `typebox.UserCreateSchema` from the client) in that case.
+You can enable Zod, TypeBox, and Elysia together. When Zod is on, `client.ts` keeps Zod as a flat `export *` and namespaces TypeBox and Elysia (`export * as typebox` / `export * as elysia`). TypeBox + Elysia without Zod keeps TypeBox flat and namespaces Elysia. Import TypeBox from `./typebox.js` (or `typebox.UserCreateSchema` from the client) when it is namespaced. For Elysia 1.x `body:`, use [`generate.elysia`](elysia.md).
 
 ## Usage
 
@@ -115,7 +115,7 @@ Typed schema helpers map into TypeBox:
 | `timestamp()` | `Date` or ISO datetime string → `Date` (`Type.Codec` + `Value.Decode`) |
 | `bytea()` | `Type.Refine` + `Buffer.isBuffer` |
 
-Raw `.check("sql")` is not mapped. With `generate.typebox: true` (or `generate.zod: true`), codegen reads inline `json()` / `jsonb()` type arguments from `schema.ts` and maps object literals to `Type.Object`, `Record<K,V>` to `Type.Record`, and primitives to the matching TypeBox types. Type aliases and imported types are not resolved yet — use an inline type or `.schema()` for those.
+Raw `.check("sql")` is not mapped. With `generate.typebox: true` (or `generate.zod` / `generate.elysia`), codegen reads inline `json()` / `jsonb()` type arguments from `schema.ts` and maps object literals to `Type.Object`, `Record<K,V>` to `Type.Record`, and primitives to the matching TypeBox types. Type aliases and imported types are not resolved yet — use an inline type or `.schema()` for those.
 
 ```ts
 metadata: jsonb<{ featured: boolean; category?: string }>(),

package/docs/zod.md

@@ -1,6 +1,6 @@
 # Zod schemas
 
-`neoorm generate` can print Select, Create, and Update **scalar** Zod schemas next to the typed client. Codegen maps your schema to a validator-neutral IR first; Zod and [TypeBox](typebox.md) are the printers shipped today.
+`neoorm generate` can print Select, Create, and Update **scalar** Zod schemas next to the typed client. Codegen maps your schema to a validator-neutral IR first; Zod, [TypeBox](typebox.md), and [Elysia `t`](elysia.md) are the printers shipped today.
 
 Generated schemas match the TypeScript shapes of row / insert / update scalars — not nested relation writes (`connect`, `create`, `set`). Those stay TypeScript-only.
 
@@ -104,7 +104,7 @@ Typed schema helpers map into Zod:
 | `json()` / `jsonb()` with `.schema()` validation IR | same as IR (`z.object`, nested `z.record`, …); wins over generics |
 | `timestamp()` | `Date` or ISO datetime string → `Date` |
 
-Raw `.check("sql")` is not mapped. With `generate.zod: true` or `generate.typebox: true`, codegen reads inline `json()` / `jsonb()` type arguments from `schema.ts` and maps object literals to `z.object`, `Record<K,V>` to `z.record`, and primitives to the matching Zod types. Type aliases and imported types are not resolved yet — use an inline type or `.schema()` for those.
+Raw `.check("sql")` is not mapped. With `generate.zod: true`, `generate.typebox: true`, or `generate.elysia: true`, codegen reads inline `json()` / `jsonb()` type arguments from `schema.ts` and maps object literals to `z.object`, `Record<K,V>` to `z.record`, and primitives to the matching Zod types. Type aliases and imported types are not resolved yet — use an inline type or `.schema()` for those.
 
 ```ts
 metadata: jsonb<{ featured: boolean; category?: string }>(),

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "neoorm",
-	"version": "0.8.1",
-	"description": "TypeScript-first PostgreSQL and SQLite ORM with schema DSL, codegen, and typed relations",
+	"version": "0.8.2",
+	"description": "TypeScript-first PostgreSQL, SQLite, MySQL, and MariaDB ORM with schema DSL, codegen, and typed relations",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -67,6 +67,8 @@
 		"postgresql",
 		"postgres",
 		"sqlite",
+		"mysql",
+		"mariadb",
 		"typescript",
 		"schema",
 		"codegen",
@@ -88,16 +90,30 @@
 		"@biomejs/biome": "2.5.2",
 		"@types/node": "^26.1.0",
 		"@types/pg": "^8.20.0",
+		"mysql2": "^3.15.3",
+		"mariadb": "^3.4.5",
 		"typebox": "^1.3.31",
 		"typescript": "^7.0.2",
 		"vitest": "^4.1.9",
 		"zod": "^4.1.5"
 	},
 	"peerDependencies": {
+		"elysia": ">=1.2.0",
+		"mysql2": ">=3.0.0",
+		"mariadb": ">=3.0.0",
 		"typebox": "^1.0.0",
 		"zod": "^4.0.0"
 	},
 	"peerDependenciesMeta": {
+		"elysia": {
+			"optional": true
+		},
+		"mysql2": {
+			"optional": true
+		},
+		"mariadb": {
+			"optional": true
+		},
 		"typebox": {
 			"optional": true
 		},