bun-query-builder 0.2.26 → 0.2.28

package/dist/db.d.ts

@@ -60,6 +60,11 @@ export declare function resetConnection(): void;
 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>;
+/**
+ * Lazy SQL connection proxy - connection is only created when first accessed.
+ * This allows setConfig() to be called before any database connection is made.
+ */
+declare function createLazyBunSql(): SQL;
 // Export a lazy proxy - no connection is made until first use
 export declare const bunSql: SQL;
 /**

package/dist/model.d.ts

@@ -79,7 +79,7 @@ export declare function registerModel<TModel>(name: string, model: TModel): TMod
  * @param definition - The model definition
  * @returns An isomorphic model with query methods
  */
-export declare function defineModel<const TDef extends BrowserModelDefinition>(definition: TDef): void;
+export declare function defineModel<const TDef extends BrowserModelDefinition>(definition: TDef): unknown;
 /**
  * Register models on the global window.StacksBrowser object.
  * Call this in your app's entry point to make models available for STX auto-imports.

package/dist/orm.d.ts

@@ -228,8 +228,11 @@ declare type PrimitiveTypeMap = {
 declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
   T extends readonly (infer U)[] ? U :
   T extends (infer U)[] ? U :
-  T extends { validate: (value: infer U) => any } ? U :
-  unknown;
+  T extends { getShape: () => infer TShape extends Readonly<Record<string, unknown>> }
+    ? { -readonly [TKey in keyof TShape]: InferType<TShape[TKey]> }
+    : T extends { test: (value: infer U) => unknown } ? U :
+      T extends { validate: (value: infer U) => unknown } ? U :
+        unknown;
 // Extract attribute keys from definition
 declare type AttributeKeys<TDef extends ModelDefinition> = keyof TDef['attributes'] & string;
 // Infer single attribute type
@@ -358,9 +361,9 @@ declare type FillableAttributes<TDef extends ModelDefinition> = Partial<Pick<
   ModelAttributes<TDef>,
   FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>> | BelongsToKeys<TDef>
 >>;
-// Numeric attribute columns — constrains aggregate methods (sum, avg, etc.)
+// Numeric attribute columns - constrains aggregate methods (sum, avg, etc.)
 declare type NumericColumns<TDef extends ModelDefinition> = {
-  [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { type: 'number' } ? K : never
+  [K in AttributeKeys<TDef>]: InferAttributeType<TDef['attributes'][K]> extends number ? K : never
 }[AttributeKeys<TDef>];
 /**
  * Relation names of one relation declaration. Array form lowercases the
@@ -369,25 +372,35 @@ declare type NumericColumns<TDef extends ModelDefinition> = {
  * 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;
 export type InferRelationNames<TDef> = | InferBelongsToNames<TDef>
   | InferHasManyNames<TDef>
   | InferHasOneNames<TDef>
   | InferBelongsToManyNames<TDef>
   | InferHasOneThroughNames<TDef>
-  | InferHasManyThroughNames<TDef>;
+  | InferHasManyThroughNames<TDef>
+  | InferMorphOneNames<TDef>
+  | InferMorphManyNames<TDef>
+  | InferMorphToManyNames<TDef>
+  | InferMorphedByManyNames<TDef>;
 /**
  * Cardinality-aware value of a loaded relation as returned by
  * `ModelInstance.getRelation()`. Relations declared as to-many (hasMany,

package/dist/schema.d.ts

@@ -62,7 +62,7 @@ export declare interface Attribute {
   fillable?: boolean
   guarded?: boolean
   foreignKey?: boolean | ForeignKeyConfig
-  factory?: (faker: Faker) => any
+  factory?: (faker: Faker) => unknown
   validation: {
     rule: ValidationType
     message?: ValidatorMessage