bun-query-builder 0.1.58 → 0.1.60

package/dist/type-inference.d.ts

@@ -32,7 +32,7 @@ declare interface InferableModelDefinition {
     readonly useAuth?: boolean | object
     readonly billable?: boolean | object
   }
-  readonly belongsTo?: readonly string[] | Readonly<Record<string, string>>
+  readonly belongsTo?: readonly (string | object)[] | Readonly<Record<string, string | object>>
   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>>
@@ -72,6 +72,41 @@ declare type ResolveDefinition<TModel> = TModel extends { getDefinition: () => i
         never;
 /** Extract user-defined attribute keys from a model definition */
 declare type DefinitionAttributeKeys<TDef extends InferableModelDefinition> = keyof TDef['attributes'] & string;
+/** The model's primary-key column name, defaulting to `id`. */
+declare type PrimaryKeyOf<TDef> = TDef extends { primaryKey: infer PK extends string } ? PK : 'id';
+/**
+ * A single `belongsTo` entry reduced to the FK column it puts on this table.
+ * Mirrors `normalizeRelationEntry` in relation-utils.ts and `BelongsToFkOf` in
+ * orm.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 — they are
+ * emitted by the migration generator, so they are as real as any declared
+ * attribute. 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.
+ */
+declare type BelongsToKeys<TDef> = TDef extends { belongsTo: infer R }
+    ? R extends readonly (infer E)[]
+      ? BelongsToFkOf<E>
+      : R extends Readonly<Record<string, infer W>>
+        ? BelongsToFkOf<W>
+        : never
+    : never;
+/** camelCase -> snake_case, matching the column names migrations emit. */
+declare type SnakeCase<S extends string> = S extends `${infer C}${infer Rest}`
+  ? C extends Lowercase<C>
+    ? `${C}${SnakeCase<Rest>}`
+    : `_${Lowercase<C>}${SnakeCase<Rest>}`
+  : S;
 // ============================================================================
 // Single attribute type inference
 // ============================================================================
@@ -93,14 +128,23 @@ export type InferAttributes<TModel> = ResolveDefinition<TModel> extends infer TD
         [K in DefinitionAttributeKeys<TDef>]: TDef['attributes'][K] extends { nullable: true }
           ? InferSingleAttributeType<TDef['attributes'][K]> | null
           : InferSingleAttributeType<TDef['attributes'][K]>
-      } & { [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 } : {})
-      & (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {})
-      & (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 } : {})
+      }
+      // A column the model spells out is the authority on its own type; the
+      // trait / FK default only fills the gap. Without the Omit, a model that
+      // declares `created_at: { type: 'date' }` alongside `useTimestamps`
+      // intersected the two into `Date & string` — an uninhabited type.
+      & Omit<
+        { [K in PrimaryKeyOf<TDef>]: 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 } : {})
+        & (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {})
+        & (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 } : {})
+        & { [K in BelongsToKeys<TDef>]: number },
+        DefinitionAttributeKeys<TDef>
+      >
     : never;
 /**
  * The full row type for a model, including an index signature for trait-added
@@ -144,6 +188,11 @@ export type ModelCreateDataLoose<TModel> = InferFillableAttributes<TModel> & { [
  * Infer only the fillable fields from a model definition or wrapped model.
  * This is the type accepted by `create()`, `update()`, and `fill()`.
  *
+ * Mirrors `InferAttributes`: a column declared `nullable: true` admits `null`.
+ * Columns that are `nullable` or carry a `default` are also OPTIONAL — the
+ * database supplies a value when the caller omits one, so requiring them at
+ * the call site rejected perfectly valid inserts.
+ *
  * @example
  * ```ts
  * type UserFillable = InferFillableAttributes<typeof UserModel>
@@ -151,11 +200,25 @@ export type ModelCreateDataLoose<TModel> = InferFillableAttributes<TModel> & { [
  * ```
  */
 export type InferFillableAttributes<TModel> = ResolveDefinition<TModel> extends infer TDef extends InferableModelDefinition
-    ? {
-        [K in DefinitionAttributeKeys<TDef> as TDef['attributes'][K] extends { fillable: true } ? K : never]:
-        InferSingleAttributeType<TDef['attributes'][K]>
-      }
+    ? FillableRequired<TDef> & FillableOptional<TDef>
     : never;
+/** Fillable keys the caller MUST supply — no `nullable`, no `default`. */
+declare type FillableRequired<TDef extends InferableModelDefinition> = {
+  [K in DefinitionAttributeKeys<TDef> as TDef['attributes'][K] extends { fillable: true }
+    ? TDef['attributes'][K] extends { nullable: true } | { default: unknown } ? never : K
+    : never]:
+  InferFillableType<TDef['attributes'][K]>
+}
+/** Fillable keys the database can fill in — `nullable` or `default`. */
+declare type FillableOptional<TDef extends InferableModelDefinition> = {
+  [K in DefinitionAttributeKeys<TDef> as TDef['attributes'][K] extends { fillable: true }
+    ? TDef['attributes'][K] extends { nullable: true } | { default: unknown } ? K : never
+    : never]?:
+  InferFillableType<TDef['attributes'][K]>
+}
+declare type InferFillableType<TAttr> = TAttr extends { nullable: true }
+  ? InferSingleAttributeType<TAttr> | null
+  : InferSingleAttributeType<TAttr>;
 /**
  * Infer the primary key type from a model definition or wrapped model.
  * Returns the literal string type of the primary key column name.
@@ -183,7 +246,9 @@ export type InferTableName<TModel> = ResolveDefinition<TModel> extends infer TDe
     : never;
 /**
  * Infer all valid relation names from a model definition or wrapped model.
- * Combines belongsTo, hasMany, hasOne, belongsToMany, hasOneThrough, and hasManyThrough.
+ * Covers every relation kind `RelationCardinality` knows about: belongsTo,
+ * hasMany, hasOne, belongsToMany, hasOneThrough, hasManyThrough, and the
+ * polymorphic morphOne / morphMany / morphToMany / morphedByMany.
  *
  * @example
  * ```ts
@@ -198,6 +263,10 @@ export type InferRelationNames<TModel> = ResolveDefinition<TModel> extends infer
     | InferBelongsToManyNames<TDef>
     | InferHasOneThroughNames<TDef>
     | InferHasManyThroughNames<TDef>
+    | InferMorphOneNames<TDef>
+    | InferMorphManyNames<TDef>
+    | InferMorphToManyNames<TDef>
+    | InferMorphedByManyNames<TDef>
     : never;
 /**
  * Infer column names that have numeric types from a model definition or wrapped model.
@@ -223,10 +292,18 @@ export type InferNumericColumns<TModel> = ResolveDefinition<TModel> extends infe
  * type UserCols = InferColumnNames<typeof UserModel>
  * // 'name' | 'email' | 'age' | 'role' | 'id' | 'uuid' | 'created_at' | 'updated_at'
  * ```
+ *
+ * Kept in parity with the ORM layer's `ColumnName`: the primary key honors a
+ * custom `primaryKey` (a custom-pk model exposes THAT column, not a phantom
+ * `id`), belongsTo-implied foreign keys are included because the migration
+ * generator emits them, and every declared attribute is also valid in its
+ * snake_case column form.
  */
 export type InferColumnNames<TModel> = ResolveDefinition<TModel> extends infer TDef extends InferableModelDefinition
     ? DefinitionAttributeKeys<TDef>
-    | 'id'
+    | SnakeCase<DefinitionAttributeKeys<TDef>>
+    | PrimaryKeyOf<TDef>
+    | BelongsToKeys<TDef>
     | (TDef['traits'] extends { useUuid: true } ? 'uuid' : never)
     | (TDef['traits'] extends { useTimestamps: true } ? 'created_at' | 'updated_at' : never)
     | (TDef['traits'] extends { timestampable: true | object } ? 'created_at' | 'updated_at' : never)
@@ -303,25 +380,35 @@ export type InferPivotColumns<TModel, R extends string> = ResolveDefinition<TMod
       : Record<string, unknown>
     : Record<string, unknown>;
 /**
- * Relation names of one relation declaration. Array form lowercases the
- * (unwrapped) model name; record form uses the keys. The array case MUST be
- * checked first: a tuple also structurally matches `Readonly<Record<...>>`
+ * Relation names of one relation declaration. A bare string (`morphOne:
+ * 'Image'`) lowercases the model name; array form lowercases the (unwrapped)
+ * model name; record form uses the keys.
+ *
+ * Order matters. The bare-string case must precede the record case (a string
+ * would otherwise fall through to `never`), and the array case MUST precede
+ * the record case: a tuple also structurally matches `Readonly<Record<...>>`
  * and would otherwise leak its own keys ('length', indices, ...) into the
  * relation-name union.
  */
-declare type RelationKeyOf<V> = V extends readonly (infer E)[]
-    ? E extends string ? Lowercase<E>
-      : E extends { model: infer M extends string } ? Lowercase<M>
-        : never
-    : V extends Readonly<Record<infer K, unknown>>
-      ? K & string
-      : never;
+declare type RelationKeyOf<V> = V extends string
+    ? Lowercase<V>
+    : V extends readonly (infer E)[]
+      ? E extends string ? Lowercase<E>
+        : E extends { model: infer M extends string } ? Lowercase<M>
+          : never
+      : V extends Readonly<Record<infer K, unknown>>
+        ? K & string
+        : never;
 declare type InferBelongsToNames<TDef> = TDef extends { belongsTo: infer V } ? RelationKeyOf<V> : never;
 declare type InferHasManyNames<TDef> = TDef extends { hasMany: infer V } ? RelationKeyOf<V> : never;
 declare type InferHasOneNames<TDef> = TDef extends { hasOne: infer V } ? RelationKeyOf<V> : never;
 declare type InferBelongsToManyNames<TDef> = TDef extends { belongsToMany: infer V } ? RelationKeyOf<V> : never;
 declare type InferHasOneThroughNames<TDef> = TDef extends { hasOneThrough: infer V } ? RelationKeyOf<V> : never;
 declare type InferHasManyThroughNames<TDef> = TDef extends { hasManyThrough: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphOneNames<TDef> = TDef extends { morphOne: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphManyNames<TDef> = TDef extends { morphMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphToManyNames<TDef> = TDef extends { morphToMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphedByManyNames<TDef> = TDef extends { morphedByMany: infer V } ? RelationKeyOf<V> : never;
 /**
  * Determine the cardinality of a relation on a model.
  * hasMany / belongsToMany / hasManyThrough / morphMany / morphToMany /

package/dist/types.d.ts

@@ -90,7 +90,7 @@ export declare interface AliasingConfig {
  */
 export declare interface RelationsConfig {
   foreignKeyFormat: 'singularParent_id' | 'parentId'
-  singularizeStrategy?: 'stripTrailingS' | 'none'
+  singularizeStrategy?: 'stripTrailingS' | 'none' | 'inflect'
   maxDepth?: number
   maxEagerLoad?: number
   detectCycles?: boolean

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.1.58",
+  "version": "0.1.60",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -80,7 +80,7 @@
     "@stacksjs/clapp": "^0.2.0",
     "@stacksjs/ts-faker": "^0.1.8",
     "@stacksjs/ts-validation": "^0.5.0",
-    "dynamodb-tooling": "^0.3.2"
+    "dynamodb-tooling": "^0.3.5"
   },
   "devDependencies": {
     "bunfig": "^0.15.6"