bun-query-builder 0.1.58 → 0.1.60

package/dist/db.d.ts

@@ -36,6 +36,10 @@ export declare function getOrCreateBunSql(forceNew?: boolean): SQL;
  * Call this after changing config via setConfig() to ensure the new config is used.
  */
 export declare function resetConnection(): void;
+/**
+ * Inject a custom SQL instance. Useful for tests or custom connection setups.
+ */
+export declare function setSqlInstance(sql: SQL): void;
 // Wrapper that catches "Connection closed" errors and retries with a fresh connection
 export declare function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Promise<T>;
 // Export a lazy proxy - no connection is made until first use

package/dist/index.d.ts

@@ -35,6 +35,7 @@ export * from './dynamodb-single-table';
 export * from './dynamodb-tooling-adapter';
 export * from './dynamodb/index';
 export * from './factory';
+export * from './inflect';
 export * from './loader';
 export * from './meta';
 export * from './migrations';

package/dist/inflect.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared singularization for relation conventions.
+ *
+ * Pivot table names and FK columns are derived by singularizing a table name
+ * (`posts` -> `post_id`, `[coach, athlete].sort().join('_')`). Four call sites
+ * — client.ts, pivot.ts, orm.ts and migrations.ts — each open-coded the same
+ * naive trailing-`s` strip, which is wrong for every table `toTableName()`
+ * pluralizes with anything other than a bare `s`:
+ *
+ *   categories -> `categorie` (want `category`)
+ *   addresses  -> `addresse`  (want `address`)
+ *   boxes      -> `boxe`      (want `box`)
+ *   status     -> `statu`     (want `status` — it was never plural)
+ *
+ * Changing the default would rename existing pivot tables and FK columns under
+ * live schemas, so `'stripTrailingS'` remains the default and the corrected
+ * behavior is opt-in via `relations.singularizeStrategy: 'inflect'`.
+ */
+/** Naive trailing-`s` strip — the historical default. */
+export declare function stripTrailingS(name: string): string;
+/**
+ * Exact inverse of `toTableName()`'s pluralization rules.
+ *
+ * Words that aren't plural under those rules (`status`, `bus`, `data`) are
+ * returned untouched — the naive strip mangled them.
+ */
+export declare function inflectSingular(name: string): string;
+/** Resolve the singularizer for a configured strategy. */
+export declare function singularizerFor(strategy: 'stripTrailingS' | 'none' | 'inflect' | undefined): (name: string) => string;

package/dist/orm.d.ts

@@ -68,6 +68,17 @@ export declare interface ModelHookInstance extends Record<string, unknown> {
   except?(keys: ReadonlyArray<string>): Record<string, unknown>
   toArray?(): Record<string, unknown>
 }
+/**
+ * Object form of a `belongsTo` entry. The migration generator has always
+ * honored `foreignKey`/`onDelete` here (see `normalizeRelationEntry`), but the
+ * declaration type only admitted plain model-name strings — so the supported
+ * form was a type error at the call site.
+ */
+export declare interface BelongsToEntry {
+  readonly model: string
+  readonly foreignKey?: string
+  readonly onDelete?: import('./schema').OnForeignKeyAction
+}
 // Base model definition
 export declare interface ModelDefinition {
   readonly name: string
@@ -113,7 +124,7 @@ export declare interface ModelDefinition {
     readonly useActivityLog?: boolean | object
     readonly useSocials?: readonly string[]
   }
-  readonly belongsTo?: readonly string[] | Readonly<Record<string, string>>
+  readonly belongsTo?: readonly (string | BelongsToEntry)[] | Readonly<Record<string, string | BelongsToEntry>>
   readonly hasMany?: readonly string[] | Readonly<Record<string, string>>
   readonly hasOne?: readonly string[] | Readonly<Record<string, string>>
   readonly belongsToMany?: readonly (string | object)[] | Readonly<Record<string, string | object>>
@@ -247,7 +258,7 @@ declare type SnakeCaseAttributes<TDef extends ModelDefinition> = {
 // System fields added by traits. The primary-key column honors the model's
 // declared `primaryKey` (default 'id') — a custom-pk model exposes THAT
 // column, not a phantom 'id'. Mirrors InferAttributes in type-inference.ts.
-declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends { primaryKey: infer PK extends string } ? PK : 'id']: number } &
+declare type TraitSystemFields<TDef extends ModelDefinition> = { [K in TDef extends { primaryKey: infer PK extends string } ? PK : 'id']: number } &
   (TDef['traits'] extends { useUuid: true } ? { uuid: string } : {}) &
   (TDef['traits'] extends { useTimestamps: true } ? { created_at: string; updated_at: string | null } : {}) &
   (TDef['traits'] extends { timestampable: true | object } ? { created_at: string; updated_at: string | null } : {}) &
@@ -255,6 +266,34 @@ declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends {
   (TDef['traits'] extends { softDeletable: true | object } ? { deleted_at: string | null } : {}) &
   (TDef['traits'] extends { useAuth: true | object } ? { two_factor_secret: string | null; public_key: string | null } : {}) &
   (TDef['traits'] extends { billable: true | object } ? { stripe_id: string | null } : {});
+/**
+ * Every column name the model declares itself, in both the casing it was
+ * written in and its snake_case column form.
+ */
+declare type DeclaredColumns<TDef extends ModelDefinition> = AttributeKeys<TDef> | SnakeCase<AttributeKeys<TDef>>;
+/**
+ * Trait-added system fields, minus anything the model declares explicitly.
+ *
+ * Without the `Omit`, a model that declares a column a trait also contributes
+ * (`created_at: { type: 'date' }` alongside `useTimestamps`, or a `user_id`
+ * string alongside `belongsTo: ['User']`) intersected the two shapes into
+ * `Date & string` — or outright `never`. Every read of that column then had an
+ * uninhabited type and every write was rejected. A column the model spells out
+ * is the authority on its own type; the trait default only fills the gap.
+ */
+declare type SystemFields<TDef extends ModelDefinition> = Omit<TraitSystemFields<TDef>, DeclaredColumns<TDef>>;
+/**
+ * A single `belongsTo` entry reduced to the FK column it puts on this table.
+ * Mirrors `normalizeRelationEntry` in relation-utils.ts: an explicit
+ * `foreignKey` wins, otherwise the name is derived from the model name.
+ */
+declare type BelongsToFkOf<E> = E extends string
+    ? `${SnakeCase<Uncapitalize<E>>}_id`
+    : E extends { foreignKey: infer F extends string }
+      ? F
+      : E extends { model: infer M extends string }
+        ? `${SnakeCase<Uncapitalize<M>>}_id`
+        : never;
 /**
  * The foreign-key columns a `belongsTo` puts on THIS model's table.
  *
@@ -264,14 +303,25 @@ declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends {
  * from both `ModelAttributes` and `ColumnName`, which made every such query a
  * type error against a column that demonstrably exists.
  *
- * The name follows the same snake_case convention the relation resolver uses
- * at runtime: `Farm` -> `farm_id`, `TreatmentMap` -> `treatment_map_id`.
+ * All four declaration shapes the migration generator accepts are covered:
+ * `['Farm']`, `[{ model: 'Farm', foreignKey: 'owner_id' }]`, `{ farm: 'Farm' }`
+ * and `{ owner: { model: 'User', foreignKey: 'owner_id' } }`. The array case
+ * MUST be checked first — a tuple also structurally matches `Record`, and the
+ * record branch would otherwise read its numeric indices as entries.
+ *
+ * The default name follows the same snake_case convention the relation resolver
+ * uses at runtime: `Farm` -> `farm_id`, `TreatmentMap` -> `treatment_map_id`.
  */
-declare type BelongsToKeys<TDef extends ModelDefinition> = TDef extends { belongsTo: infer R extends readonly string[] }
-    ? `${SnakeCase<Uncapitalize<R[number]>>}_id`
+declare type BelongsToKeys<TDef extends ModelDefinition> = TDef extends { belongsTo: infer R }
+    ? R extends readonly (infer E)[]
+      ? BelongsToFkOf<E>
+      : R extends Readonly<Record<string, infer W>>
+        ? BelongsToFkOf<W>
+        : never
     : never;
+// A declared attribute of the same name wins — see SystemFields above.
 declare type BelongsToColumns<TDef extends ModelDefinition> = {
-  [K in BelongsToKeys<TDef>]: number
+  [K in Exclude<BelongsToKeys<TDef>, DeclaredColumns<TDef>>]: number
 }
 // Complete model type
 declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SnakeCaseAttributes<TDef> & SystemFields<TDef> & BelongsToColumns<TDef>;
@@ -295,9 +345,18 @@ declare type HiddenKeys<TDef extends ModelDefinition> = {
 declare type FillableKeys<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { fillable: true } ? K : never
 }[AttributeKeys<TDef>];
+/**
+ * `belongsTo` foreign keys are always writable.
+ *
+ * Attaching a record to its parent IS the create: `Mission.create({ …,
+ * field_id: field.id })`. There is no attribute declaration to put
+ * `fillable: true` on, because the column comes from the relation rather than
+ * from `attributes`, so without this every such create was a type error
+ * against the one column the relation exists to set.
+ */
 declare type FillableAttributes<TDef extends ModelDefinition> = Partial<Pick<
   ModelAttributes<TDef>,
-  FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>>
+  FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>> | BelongsToKeys<TDef>
 >>;
 // Numeric attribute columns — constrains aggregate methods (sum, avg, etc.)
 declare type NumericColumns<TDef extends ModelDefinition> = {