qubu 0.4.0 → 0.4.2

package/dist/vite.d.mts

@@ -1,9 +1,8 @@
 //#region src/vite/globals.d.ts
 /**
- * Public runtime names that the `"use qubu"` transform can auto-import.
- * Keep this catalog aligned with the ordinary authoring surface of `qubu`;
- * fragment internals, dialect construction, and schema extensions belong to
- * the layered entrypoints.
+ * Public runtime names that the `"use qubu"` transform can auto-import. Keep this catalog aligned
+ * with the ordinary authoring surface of `qubu`; fragment internals, dialect construction, and
+ * schema extensions belong to the layered entrypoints.
  */
 declare const qubuGlobals: readonly ["add", "alias", "all", "allowAll", "and", "asc", "asValue", "avg", "bigint", "between", "binary", "boolean", "call", "caseWhen", "cast", "check", "coalesce", "column", "concat", "count", "countDistinct", "correlate", "crossJoin", "cte", "date", "denseRank", "defaultValues", "deleteFrom", "desc", "distinct", "divide", "eq", "except", "execute", "executeRows", "externalDefault", "externalGeneratedColumn", "exists", "fetchFirst", "fetchNext", "foreignKey", "from", "fullJoin", "generatedColumn", "gt", "gte", "groupBy", "having", "identityColumn", "inList", "inQuery", "index", "innerJoin", "insertInto", "insertSelect", "integer", "intersect", "isDistinctFrom", "isNotDistinctFrom", "isNotNull", "isNull", "isTrue", "json", "jsonBoolean", "jsonExists", "jsonNumber", "jsonPath", "jsonText", "lateral", "leftJoin", "like", "lower", "lt", "lte", "max", "min", "modulo", "multiply", "naturalJoin", "nativeColumn", "nativeStorage", "ne", "not", "notExists", "notIn", "notLike", "nullsFirst", "nullsLast", "numeric", "nullable", "offset", "omit", "or", "order", "orderBy", "over", "portableStorage", "primaryKey", "qubu", "references", "recursiveCte", "render", "returning", "rightJoin", "rank", "rowNumber", "scalar", "schema", "schemaCall", "select", "sql", "stream", "subtract", "sum", "table", "text", "timestamp", "union", "unionAll", "unique", "uniqueConstraint", "update", "upper", "value", "values", "where", "withCte", "uuid"];
 type QubuGlobal = (typeof qubuGlobals)[number];
@@ -25,8 +24,8 @@ interface QubuViteTransformResult {
 }
 /** A Vite-compatible plugin without a runtime dependency on Vite itself. */
 interface QubuVitePlugin {
-  readonly name: 'qubu:compiler-hint';
-  readonly enforce: 'pre';
+  readonly name: "qubu:compiler-hint";
+  readonly enforce: "pre";
   transform(code: string, id: string): QubuViteTransformResult | null;
 }
 declare function qubu(options?: QubuVitePluginOptions): QubuVitePlugin;

package/dist/vite.mjs

@@ -70,10 +70,9 @@ function isWhitespace$1(character) {
 //#endregion
 //#region src/vite/globals.ts
 /**
-* Public runtime names that the `"use qubu"` transform can auto-import.
-* Keep this catalog aligned with the ordinary authoring surface of `qubu`;
-* fragment internals, dialect construction, and schema extensions belong to
-* the layered entrypoints.
+* Public runtime names that the `"use qubu"` transform can auto-import. Keep this catalog aligned
+* with the ordinary authoring surface of `qubu`; fragment internals, dialect construction, and
+* schema extensions belong to the layered entrypoints.
 */
 const qubuGlobals = [
 	"add",

package/docs/dialects-and-execution.md

@@ -20,8 +20,8 @@ Construct the query without choosing a driver, then render it with the policy
 the adapter expects:
 
 ```ts
-import { render } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { render } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
 const standard = render(query)
 const postgres = render(query, postgresDialect())
@@ -40,15 +40,11 @@ capability requirement to the rendering boundary. PostgreSQL's `ilike()` is
 the first such feature:
 
 ```ts
-import { from, like, render, select, where } from 'qubu'
-import { ilike, postgresDialect } from 'qubu/postgres'
-import { sqliteDialect } from 'qubu/sqlite'
+import { from, like, render, select, where } from "qubu"
+import { ilike, postgresDialect } from "qubu/postgres"
+import { sqliteDialect } from "qubu/sqlite"
 
-const postgresQuery = select(
-  { name: users.name },
-  from(users),
-  where(ilike(users.name, '%ada%'))
-)
+const postgresQuery = select({ name: users.name }, from(users), where(ilike(users.name, "%ada%")))
 
 render(postgresQuery, postgresDialect()) // supported
 render(postgresQuery, sqliteDialect()) // TypeScript error
@@ -59,14 +55,10 @@ received from an untyped integration. Use the portable operator when the
 query must render across dialects:
 
 ```ts
-import { from, like, render, select, where } from 'qubu'
-import { sqliteDialect } from 'qubu/sqlite'
+import { from, like, render, select, where } from "qubu"
+import { sqliteDialect } from "qubu/sqlite"
 
-const portableQuery = select(
-  { name: users.name },
-  from(users),
-  where(like(users.name, '%ada%'))
-)
+const portableQuery = select({ name: users.name }, from(users), where(like(users.name, "%ada%")))
 
 render(portableQuery)
 render(portableQuery, sqliteDialect())
@@ -88,15 +80,15 @@ to produce the typed `ExecutionResult`. A `TransactionalQueryAdapter` can also
 pin one driver connection for a callback transaction:
 
 ```ts
-import { qubu } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
-import type { ExecutionRequest, QueryAdapter } from 'qubu'
+import { qubu } from "qubu"
+import { postgresDialect } from "qubu/postgres"
+import type { ExecutionRequest, QueryAdapter } from "qubu"
 
 declare const driver: {
   query<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): Promise<{ rows: readonly TRow[]; rowCount: number | null }>
 }
 
@@ -107,13 +99,11 @@ const adapter: QueryAdapter = {
     const result = await driver.query<Record<string, unknown>>(
       statement.text,
       statement.parameters,
-      { signal }
+      { signal },
     )
     return {
       rows: result.rows,
-      ...(queryKind !== 'select' &&
-      queryKind !== 'set' &&
-      result.rowCount !== null
+      ...(queryKind !== "select" && queryKind !== "set" && result.rowCount !== null
         ? { affectedRows: result.rowCount }
         : {}),
     }
@@ -134,9 +124,9 @@ import {
   dateResultDecoder,
   jsonTextResultDecoder,
   timestampResultDecoder,
-} from 'qubu'
-import type { AdapterExecutionResult, QueryAdapter, RenderedQuery } from 'qubu'
-import { sqliteDialect } from 'qubu/sqlite'
+} from "qubu"
+import type { AdapterExecutionResult, QueryAdapter, RenderedQuery } from "qubu"
+import { sqliteDialect } from "qubu/sqlite"
 
 declare const sqliteDriver: {
   execute(statement: RenderedQuery): Promise<AdapterExecutionResult>
@@ -165,10 +155,10 @@ Use a column decoder for a custom stored type, or `mapResult()` for one
 expression. Both override adapter policy for that field:
 
 ```ts
-import { column, mapResult, value } from 'qubu'
+import { column, mapResult, value } from "qubu"
 
-const score = column<number>({ decode: value => Number(value) })
-const decodedTotal = mapResult(value('42'), value => Number(value))
+const score = column<number>({ decode: (value) => Number(value) })
+const decodedTotal = mapResult(value("42"), (value) => Number(value))
 ```
 
 ## Stream read results
@@ -180,20 +170,20 @@ Mutations stay on `execute()` and `executeRows()`, including mutations with
 `RETURNING`.
 
 ```ts
-import { qubu } from 'qubu'
-import type { ExecutionRequest, StreamingQueryAdapter } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { qubu } from "qubu"
+import type { ExecutionRequest, StreamingQueryAdapter } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
 declare const driver: {
   query<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): Promise<{ rows: readonly TRow[]; rowCount: number | null }>
   stream<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): AsyncIterable<TRow>
 }
 
@@ -203,7 +193,7 @@ const adapter: StreamingQueryAdapter = {
     const result = await driver.query<Record<string, unknown>>(
       request.statement.text,
       request.statement.parameters,
-      { signal: request.signal }
+      { signal: request.signal },
     )
     return {
       rows: result.rows,
@@ -214,7 +204,7 @@ const adapter: StreamingQueryAdapter = {
     return driver.stream<Record<string, unknown>>(
       request.statement.text,
       request.statement.parameters,
-      { signal: request.signal }
+      { signal: request.signal },
     )
   },
 }
@@ -259,10 +249,10 @@ transaction callback receives a streaming client. The adapter must keep its
 cursor and connection valid until the callback's streams finish or close:
 
 ```ts
-declare const transactionalAdapter: import('qubu').StreamingTransactionalQueryAdapter
+declare const transactionalAdapter: import("qubu").StreamingTransactionalQueryAdapter
 const transactionalDb = qubu(transactionalAdapter)
 
-await transactionalDb.transaction(async transaction => {
+await transactionalDb.transaction(async (transaction) => {
   for await (const row of transaction.stream(readQuery)) {
     consume(row)
   }
@@ -281,17 +271,17 @@ standalone `explain()` function and the bound `db.explain()` method render a
 plan request without calling `execute()`:
 
 ```ts
-import { explain, qubu } from 'qubu'
-import type { ExplainableQueryAdapter } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { explain, qubu } from "qubu"
+import type { ExplainableQueryAdapter } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
-type PostgresPlanRow = { 'QUERY PLAN': string }
+type PostgresPlanRow = { "QUERY PLAN": string }
 
 declare const driver: {
   query<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): Promise<{ rows: readonly TRow[] }>
 }
 
@@ -304,7 +294,7 @@ const adapter: ExplainableQueryAdapter<PostgresPlanRow> = {
     const result = await driver.query<PostgresPlanRow>(
       request.statement.text,
       request.statement.parameters,
-      { signal: request.signal }
+      { signal: request.signal },
     )
     return { rows: result.rows }
   },
@@ -369,13 +359,13 @@ Use a transactional adapter when several queries must share one commit or
 rollback boundary:
 
 ```ts
-import { qubu } from 'qubu'
-import type { TransactionalQueryAdapter } from 'qubu'
+import { qubu } from "qubu"
+import type { TransactionalQueryAdapter } from "qubu"
 
 declare const transactionalAdapter: TransactionalQueryAdapter
 const transactionalDb = qubu(transactionalAdapter)
 
-const result = await transactionalDb.transaction(async transaction => {
+const result = await transactionalDb.transaction(async (transaction) => {
   await transaction.execute(firstMutation)
   await transaction.execute(secondMutation)
   return transaction.rows(readQuery)
@@ -400,7 +390,7 @@ The standalone functions remain useful when the adapter varies by call or a
 small module does not need a bound client:
 
 ```ts
-import { execute, executeRows } from 'qubu'
+import { execute, executeRows } from "qubu"
 
 const result = await execute(query, adapter)
 const rows = await executeRows(readQuery, adapter)
@@ -449,13 +439,13 @@ Use `createDialect()` when a driver needs a different policy but the query
 syntax stays portable:
 
 ```ts
-import { render } from 'qubu'
-import { createDialect } from 'qubu/core'
+import { render } from "qubu"
+import { createDialect } from "qubu/core"
 
 const namedParameters = createDialect({
-  name: 'named-parameters',
-  placeholder: position => `:p${position}`,
-  castTypes: { text: 'STRING' },
+  name: "named-parameters",
+  placeholder: (position) => `:p${position}`,
+  castTypes: { text: "STRING" },
 })
 
 const statement = render(query, namedParameters)

package/docs/getting-started.md

@@ -24,9 +24,9 @@ Use `table()` once for each query-facing table. Column helpers describe the
 application values that can be selected and, for mutations, written.
 
 ```ts
-import { integer, table, text } from 'qubu'
+import { integer, table, text } from "qubu"
 
-const users = table('users', {
+const users = table("users", {
   id: integer(),
   name: text(),
   email: text({ nullable: true }),
@@ -44,7 +44,7 @@ it, then renders the normalized statement in SQL order. The example uses the
 `users` table from the previous section.
 
 ```ts
-import { eq, from, render, select, where } from 'qubu'
+import { eq, from, render, select, where } from "qubu"
 
 const query = select(
   {
@@ -52,7 +52,7 @@ const query = select(
     displayName: users.name,
   },
   from(users),
-  where(eq(users.id, 7))
+  where(eq(users.id, 7)),
 )
 
 const statement = render(query)

package/docs/guides/better-auth.md

@@ -0,0 +1,57 @@
+# Better Auth
+
+> Derive Qubu-owned auth tables and run Better Auth through a transactional Qubu client.
+
+Install the integration next to Qubu and Better Auth:
+
+```sh
+pnpm add qubu @qubu/better-auth better-auth
+```
+
+Define the Better Auth options once. The schema derivation reads Better Auth's
+resolved public metadata, so core tables, renamed models and fields, additional
+fields, plugin tables, references, unique constraints, and compound indexes all
+participate.
+
+```ts
+import { betterAuth } from "better-auth"
+import type { BetterAuthOptions } from "better-auth/types"
+import { twoFactor } from "better-auth/plugins"
+import { betterAuthSchema, qubuAdapter } from "@qubu/better-auth"
+import { qubu } from "qubu"
+import { pgAdapter } from "@qubu/adapter-pg"
+
+const options = {
+  user: {
+    modelName: "auth_users",
+    additionalFields: {
+      locale: { type: "string", required: false },
+    },
+  },
+  plugins: [twoFactor()],
+} satisfies BetterAuthOptions
+
+const authSchema = betterAuthSchema(options, "postgresql")
+const db = qubu(pgAdapter(pool))
+
+export const auth = betterAuth({
+  ...options,
+  database: qubuAdapter(db, { schema: authSchema }),
+})
+```
+
+`authSchema` is an ordinary Qubu `Schema`. Hand it to Qubu snapshot, diff,
+migration-plan, and DDL workflows. The adapter's Better Auth `createSchema`
+hook emits a TypeScript module that reconstructs the same Qubu-owned metadata.
+
+The package never imports PostgreSQL, MySQL, or SQLite drivers. It executes
+through Qubu's query and transaction boundaries. PostgreSQL and SQLite use one
+limited mutation statement for atomic consume and guarded increment operations;
+MySQL locks one selected row inside the Qubu-owned transaction. A client without
+transaction support, or a dialect other than PostgreSQL, MySQL, or SQLite, is
+rejected during adapter construction.
+
+Better Auth enum metadata is currently rejected because Qubu cannot preserve
+the closed value set as a portable column without adding a database constraint.
+The error includes the model and field path instead of silently widening it to
+text.

package/docs/guides/compose-queries.md

@@ -8,37 +8,19 @@
 Attach it with `withCte()` and use the CTE source in `from()`:
 
 ```ts
-import {
-  cte,
-  eq,
-  from,
-  integer,
-  select,
-  table,
-  text,
-  where,
-  withCte,
-} from 'qubu'
-
-const users = table('users', {
+import { cte, eq, from, integer, select, table, text, where, withCte } from "qubu"
+
+const users = table("users", {
   id: integer(),
   name: text(),
 })
 
 const activeUsers = cte(
-  'active_users',
-  select(
-    { id: users.id, name: users.name },
-    from(users),
-    where(eq(users.id, 7))
-  )
+  "active_users",
+  select({ id: users.id, name: users.name }, from(users), where(eq(users.id, 7))),
 )
 
-const report = select(
-  { displayName: activeUsers.name },
-  withCte(activeUsers),
-  from(activeUsers)
-)
+const report = select({ displayName: activeUsers.name }, withCte(activeUsers), from(activeUsers))
 ```
 
 `activeUsers.name` is a typed column derived from the first query's row shape.
@@ -53,24 +35,10 @@ member. The callback receives a typed self-reference; introduce it through
 `from()` or a join before selecting its fields:
 
 ```ts
-import {
-  add,
-  cast,
-  from,
-  integer,
-  lt,
-  recursiveCte,
-  select,
-  value,
-  where,
-  withCte,
-} from 'qubu'
-
-const numbers = recursiveCte(
-  'numbers',
-  select({ value: cast(value(1), integer()) }),
-  self =>
-    select({ value: add(self.value, 1) }, from(self), where(lt(self.value, 3)))
+import { add, cast, from, integer, lt, recursiveCte, select, value, where, withCte } from "qubu"
+
+const numbers = recursiveCte("numbers", select({ value: cast(value(1), integer()) }), (self) =>
+  select({ value: add(self.value, 1) }, from(self), where(lt(self.value, 3))),
 )
 
 const query = select({ value: numbers.value }, withCte(numbers), from(numbers))
@@ -89,11 +57,11 @@ recursive CTEs can share one `withCte()` clause.
 Alias a query when it should be used as an inline source:
 
 ```ts
-import { alias, from, lower, select } from 'qubu'
-import type { SqlTypeOf } from 'qubu'
+import { alias, from, lower, select } from "qubu"
+import type { SqlTypeOf } from "qubu"
 
 const names = select({ name: lower(users.name) }, from(users))
-const namesSource = alias(names, 'names')
+const namesSource = alias(names, "names")
 
 const query = select({ name: namesSource.name }, from(namesSource))
 type NameSqlDomain = SqlTypeOf<typeof namesSource.name>
@@ -112,7 +80,7 @@ so downstream text operations remain checked without redeclaring the field.
 `scalar()` turns a query with exactly one selected field into an expression:
 
 ```ts
-import { from, scalar, select, value } from 'qubu'
+import { from, scalar, select, value } from "qubu"
 
 const firstId = select({ id: users.id }, from(users))
 const query = select(
@@ -120,7 +88,7 @@ const query = select(
     name: users.name,
     firstId: scalar(firstId),
   },
-  from(users)
+  from(users),
 )
 ```
 
@@ -139,7 +107,7 @@ Set operations preserve the left query's row shape. Both queries must select
 compatible rows:
 
 ```ts
-import { eq, from, select, unionAll, where } from 'qubu'
+import { eq, from, select, unionAll, where } from "qubu"
 
 const first = select({ id: users.id }, from(users))
 const second = select({ id: users.id }, from(users), where(eq(users.id, 7)))
@@ -156,17 +124,12 @@ are collected in traversal order.
 Build reusable pieces as ordinary values and pass them into the final query:
 
 ```ts
-import { desc, eq, from, orderBy, select, where } from 'qubu'
+import { desc, eq, from, orderBy, select, where } from "qubu"
 
 const byId = where(eq(users.id, 7))
 const newest = orderBy(desc(users.id))
 
-const query = select(
-  { id: users.id, name: users.name },
-  from(users),
-  byId,
-  newest
-)
+const query = select({ id: users.id, name: users.name }, from(users), byId, newest)
 ```
 
 This makes it possible to share a predicate or projection without mutating a
@@ -185,13 +148,10 @@ generic function retains its exact source identity.
 For an application-level requirement, describe the required JavaScript row:
 
 ```ts
-import { eq, where } from 'qubu'
-import type { TableLike } from 'qubu'
+import { eq, where } from "qubu"
+import type { TableLike } from "qubu"
 
-function byStringId<TTable extends TableLike<{ id: string }>>(
-  table: TTable,
-  id: string
-) {
+function byStringId<TTable extends TableLike<{ id: string }>>(table: TTable, id: string) {
   return where(eq(table.columns.id, id))
 }
 ```
@@ -203,18 +163,15 @@ extra fields and rejects `string | null`, but it does not distinguish
 Use `FieldLike` when the fragment depends on SQL semantics:
 
 ```ts
-import { eq, where } from 'qubu'
-import type { FieldLike, SourceLike, SqlTextLike } from 'qubu'
+import { eq, where } from "qubu"
+import type { FieldLike, SourceLike, SqlTextLike } from "qubu"
 
 type NonNullTextId = FieldLike<{
   sqlType: SqlTextLike
   nullable: false
 }>
 
-function byTextId<TSource extends SourceLike<{ id: NonNullTextId }>>(
-  source: TSource,
-  id: string
-) {
+function byTextId<TSource extends SourceLike<{ id: NonNullTextId }>>(source: TSource, id: string) {
   return where(eq(source.columns.id, id))
 }
 ```

package/docs/guides/drizzle.md

@@ -5,11 +5,11 @@
 
 ## Install the optional integration
 
-Install Drizzle next to Qubu. The Drizzle entrypoints use an optional peer
-dependency, so importing the rest of Qubu does not load the ORM.
+Install the integration next to Qubu and Drizzle. The `@qubu/drizzle` package
+owns schema conversion; the root `qubu` package does not depend on Drizzle.
 
 ```bash
-pnpm add qubu drizzle-orm@rc
+pnpm add qubu @qubu/drizzle drizzle-orm@rc
 ```
 
 The converter supports PostgreSQL, MySQL, and SQLite with Drizzle 1.0.0-rc.4
@@ -21,29 +21,29 @@ Declare tables and the root registry with Qubu, then import the converter for
 your database:
 
 ```ts
-import { integer, schema, table, text } from 'qubu'
-import { toPostgresDrizzleSchema } from 'qubu/drizzle/postgres'
+import { integer, schema, table, text } from "qubu"
+import { toPostgresDrizzleSchema } from "@qubu/drizzle/postgres"
 
-const users = table('user_records', {
+const users = table("user_records", {
   id: integer({ generated: true }),
   name: text(),
   nickname: text({ nullable: true }),
 })
 
-const appSchema = schema({ users }, { namespace: 'app' })
+const appSchema = schema({ users }, { namespace: "app" })
 const drizzleTables = toPostgresDrizzleSchema(appSchema)
 ```
 
 The import path selects the dialect. Each module imports only its matching
 Drizzle core package:
 
-| Database   | Import                  | Converter                   |
-| ---------- | ----------------------- | --------------------------- |
-| PostgreSQL | `qubu/drizzle/postgres` | `toPostgresDrizzleSchema()` |
-| MySQL      | `qubu/drizzle/mysql`    | `toMysqlDrizzleSchema()`    |
-| SQLite     | `qubu/drizzle/sqlite`   | `toSqliteDrizzleSchema()`   |
+| Database   | Import                   | Converter                   |
+| ---------- | ------------------------ | --------------------------- |
+| PostgreSQL | `@qubu/drizzle/postgres` | `toPostgresDrizzleSchema()` |
+| MySQL      | `@qubu/drizzle/mysql`    | `toMysqlDrizzleSchema()`    |
+| SQLite     | `@qubu/drizzle/sqlite`   | `toSqliteDrizzleSchema()`   |
 
-`qubu/drizzle` exports the shared conversion error and dialect types. It does
+`@qubu/drizzle` exports the shared conversion error and dialect types. It does
 not import a dialect core or provide a universal runtime converter.
 
 `drizzleTables.users` is a real Drizzle `PgTable`. The logical `users` key,
@@ -54,8 +54,8 @@ Use the converted tables in ordinary Drizzle queries. Table objects do not need
 to be passed to `drizzle()`:
 
 ```ts
-import { eq } from 'drizzle-orm'
-import { drizzle } from 'drizzle-orm/node-postgres'
+import { eq } from "drizzle-orm"
+import { drizzle } from "drizzle-orm/node-postgres"
 
 const db = drizzle(pool)
 
@@ -74,12 +74,12 @@ Use `sqliteTimestamp()` when an existing SQLite schema stores dates as integer
 Unix timestamps and Drizzle must continue reading and writing `Date` values:
 
 ```ts
-import { schema, table } from 'qubu'
-import { sqliteTimestamp, toSqliteDrizzleSchema } from 'qubu/drizzle/sqlite'
+import { schema, table } from "qubu"
+import { sqliteTimestamp, toSqliteDrizzleSchema } from "@qubu/drizzle/sqlite"
 
-const events = table('events', {
+const events = table("events", {
   createdAt: sqliteTimestamp({
-    mode: 'timestamp',
+    mode: "timestamp",
     defaultFn: () => new Date(),
   }),
 })
@@ -127,11 +127,11 @@ unique constraints, checks, foreign keys, and indexes. Native storage must
 belong to the selected dialect:
 
 ```ts
-import { nativeColumn, schema, table } from 'qubu'
-import { toPostgresDrizzleSchema } from 'qubu/drizzle/postgres'
+import { nativeColumn, schema, table } from "qubu"
+import { toPostgresDrizzleSchema } from "@qubu/drizzle/postgres"
 
-const records = table('records', {
-  handle: nativeColumn('postgresql', 'CITEXT'),
+const records = table("records", {
+  handle: nativeColumn("postgresql", "CITEXT"),
 })
 
 const tables = toPostgresDrizzleSchema(schema({ records }))

package/docs/guides/extensions/dialects.md

@@ -8,12 +8,12 @@ identifiers, placeholders, or pagination:
 The examples assume a query has already been built.
 
 ```ts
-import { render } from 'qubu'
-import { createDialect } from 'qubu/core'
+import { render } from "qubu"
+import { createDialect } from "qubu/core"
 
 const colonDialect = createDialect({
-  name: 'colon',
-  placeholder: position => ':p' + position,
+  name: "colon",
+  placeholder: (position) => ":p" + position,
 })
 
 render(query, colonDialect)