@stacksjs/orm 0.70.368 → 0.70.370

package/dist/model-types.d.ts

@@ -1,17 +1,106 @@
-import type { InferAttributes as QueryInferAttributes, InferColumnNames as QueryInferColumnNames, InferFillableAttributes as QueryInferFillableAttributes, InferNumericColumns as QueryInferNumericColumns, ModelRow as QueryModelRow } from '@stacksjs/query-builder';
+import type { MODEL_DEFINITION } from './define-model';
+import type { Validator } from '@stacksjs/validation';
 /**
  * Extract the raw ModelDefinition from a defineModel() return value.
  * Uses the getDefinition() accessor that defineModel() provides.
  */
-export type Def<T> = T extends { getDefinition: () => infer D } ? D : never;
+export type Def<T> = T extends { readonly [MODEL_DEFINITION]: infer TDefinition }
+  ? TDefinition
+  : T extends { getDefinition: () => infer TDefinition }
+    ? TDefinition
+    : never;
 /**
  * Extract foreign key columns from belongsTo relations.
  * e.g., belongsTo: ['Customer', 'Coupon'] → { customer_id: number, coupon_id: number }
  */
-// eslint-disable-next-line ts/no-empty-object-type
-export type BelongsToForeignKeys<TDef> = TDef extends { readonly belongsTo: readonly (infer R extends string)[] }
-    ? { [K in R as `${Lowercase<K>}_id`]: number }
-    : {}
+declare type SnakeCase<S extends string> = S extends `${infer TFirst}${infer TRest}`
+  ? TFirst extends Lowercase<TFirst>
+    ? `${TFirst}${SnakeCase<TRest>}`
+    : `_${Lowercase<TFirst>}${SnakeCase<TRest>}`
+  : S;
+declare type BelongsToForeignKeyOf<TEntry> = TEntry extends string
+  ? `${SnakeCase<Uncapitalize<TEntry>>}_id`
+  : TEntry extends { readonly foreignKey: infer TForeignKey extends string }
+    ? TForeignKey
+    : TEntry extends { readonly model: infer TModel extends string }
+      ? `${SnakeCase<Uncapitalize<TModel>>}_id`
+      : never;
+declare type BelongsToForeignKeyNames<TDef> = TDef extends { readonly belongsTo: infer TRelations }
+  ? TRelations extends readonly (infer TEntry)[]
+    ? BelongsToForeignKeyOf<TEntry>
+    : TRelations extends Readonly<Record<string, infer TEntry>>
+      ? BelongsToForeignKeyOf<TEntry>
+      : never
+  : never;
+export type BelongsToForeignKeys<TDef> = {
+  [TKey in BelongsToForeignKeyNames<TDef>]: number
+}
+declare type DefinitionAttributes<TDef> = TDef extends { readonly attributes: infer TAttributes }
+  ? TAttributes
+  : never;
+declare type AttributeKeys<TDef> = keyof DefinitionAttributes<TDef> & string;
+declare type PrimitiveType<TType> = TType extends 'string'
+  ? string
+  : TType extends 'number' ? number
+    : TType extends 'boolean' ? boolean
+      : TType extends 'date' ? Date
+        : TType extends 'json' ? Record<string, unknown>
+          : TType extends readonly (infer TValue)[] ? TValue
+            : TType extends Validator<infer TValue> ? TValue
+              : unknown;
+declare type WidenDefault<TValue> = TValue extends string
+  ? string
+  : TValue extends number ? number
+    : TValue extends boolean ? boolean
+      : TValue;
+declare type AttributeValue<TAttribute> = TAttribute extends { readonly type: infer TType }
+  ? PrimitiveType<TType>
+  : TAttribute extends { readonly factory: (...args: never[]) => infer TValue } ? TValue
+    : TAttribute extends { readonly validation: { readonly rule: infer TRule } }
+      ? TRule extends Validator<infer TValue> ? TValue : unknown
+      : TAttribute extends { readonly default: infer TDefault } ? WidenDefault<TDefault>
+        : unknown;
+declare type DeclaredAttributes<TDef> = {
+  [TKey in AttributeKeys<TDef>]: DefinitionAttributes<TDef>[TKey] extends { readonly nullable: true }
+    ? AttributeValue<DefinitionAttributes<TDef>[TKey]> | null
+    : AttributeValue<DefinitionAttributes<TDef>[TKey]>
+}
+declare type SnakeCaseAttributes<TDef> = {
+  [TKey in AttributeKeys<TDef> as SnakeCase<TKey>]: DeclaredAttributes<TDef>[TKey]
+}
+declare type PrimaryKey<TDef> = TDef extends { readonly primaryKey: infer TKey extends string } ? TKey : 'id';
+declare type TraitFields<TDef> = { [TKey in PrimaryKey<TDef>]: number }
+  & (TDef extends { readonly traits: { readonly useUuid: true } } ? { uuid: string } : {})
+  & (TDef extends { readonly traits: { readonly useTimestamps: true } } ? {
+    created_at: string
+    updated_at: string | null
+  } : {})
+  & (TDef extends { readonly traits: { readonly timestampable: true | object } } ? {
+    created_at: string
+    updated_at: string | null
+  } : {})
+  & (TDef extends { readonly traits: { readonly useSoftDeletes: true } } ? { deleted_at: string | null } : {})
+  & (TDef extends { readonly traits: { readonly softDeletable: true | object } } ? { deleted_at: string | null } : {})
+  & (TDef extends { readonly traits: { readonly useAuth: true | object } } ? {
+    two_factor_secret: string | null
+    public_key: string | null
+  } : {})
+  & (TDef extends { readonly traits: { readonly billable: true } } ? { stripe_id: string | null } : {});
+declare type InferredModelRow<TDef> = DeclaredAttributes<TDef>
+  & SnakeCaseAttributes<TDef>
+  & Omit<TraitFields<TDef>, AttributeKeys<TDef> | SnakeCase<AttributeKeys<TDef>>>
+  & Omit<BelongsToForeignKeys<TDef>, AttributeKeys<TDef> | SnakeCase<AttributeKeys<TDef>>>;
+declare type FillableKeys<TDef> = {
+  [TKey in AttributeKeys<TDef>]: DefinitionAttributes<TDef>[TKey] extends { readonly fillable: true }
+    ? TKey
+    : never
+}[AttributeKeys<TDef>];
+declare type OptionalFillableKeys<TDef> = {
+  [TKey in FillableKeys<TDef>]: DefinitionAttributes<TDef>[TKey] extends
+  { readonly nullable: true } | { readonly default: unknown }
+    ? TKey
+    : never
+}[FillableKeys<TDef>];
 /**
  * Full database row type: model attributes + system fields (id, uuid, timestamps) + FK columns.
  *
@@ -20,7 +109,7 @@ export type BelongsToForeignKeys<TDef> = TDef extends { readonly belongsTo: read
  * import type Post from '../models/Post'
  * type PostJsonResponse = ModelRow<typeof Post>
  */
-export type ModelRow<T> = QueryModelRow<T> & BelongsToForeignKeys<Def<T>>;
+export type ModelRow<T> = InferredModelRow<Def<T>>;
 /**
  * Same as {@link ModelRow} but with every field optional. Useful for
  * partial-projection reads (`select('id', 'name')`) and test fixtures
@@ -35,7 +124,7 @@ export type ModelRowLoose<T> = Partial<ModelRow<T>>;
  * import type Post from '../models/Post'
  * type NewPost = NewModelData<typeof Post>
  */
-export type NewModelData<T> = Partial<QueryInferAttributes<T> & BelongsToForeignKeys<Def<T>>>;
+export type NewModelData<T> = Partial<ModelRow<T>>;
 /**
  * Strict insertable shape: only attributes marked `fillable: true` in
  * the model definition (plus belongsTo foreign keys), partial because
@@ -45,7 +134,7 @@ export type NewModelData<T> = Partial<QueryInferAttributes<T> & BelongsToForeign
  * can't pass non-fillable fields to `create()` / `insert()`.
  * {@link NewModelData} is the looser sibling that allows any attribute.
  */
-export type ModelCreateData<T> = Partial<QueryInferFillableAttributes<T>> & BelongsToForeignKeys<Def<T>>;
+export type ModelCreateData<T> = Partial<InferFillableAttributes<T> & BelongsToForeignKeys<Def<T>>>;
 /** Loose variant of {@link ModelCreateData} — same shape as {@link NewModelData}, aliased for naming-parity with the row types. */
 export type ModelCreateDataLoose<T> = NewModelData<T>;
 /**
@@ -56,23 +145,23 @@ export type ModelCreateDataLoose<T> = NewModelData<T>;
  * import type Post from '../models/Post'
  * type PostUpdate = UpdateModelData<typeof Post>
  */
-export type UpdateModelData<T> = Partial<QueryInferAttributes<T> & BelongsToForeignKeys<Def<T>>>;
-/**
- * Just the attribute records flagged `fillable: true` — useful for
- * code-generators and any helper that needs the typed shape of a
- * model's fillable-attribute config (e.g., admin form schemas).
- */
+export type UpdateModelData<T> = Partial<ModelRow<T>>;
+/** Attribute values accepted by mass-assignment writes. */
 export type InferFillableAttributes<T> = {
-  [K in keyof QueryInferFillableAttributes<T>]: Def<T> extends { attributes: infer A }
-    ? K extends keyof A ? A[K] : never
-    : never
+  [TKey in Exclude<FillableKeys<Def<T>>, OptionalFillableKeys<Def<T>>>]: DeclaredAttributes<Def<T>>[TKey]
+} & {
+  [TKey in OptionalFillableKeys<Def<T>>]?: DeclaredAttributes<Def<T>>[TKey]
 }
 /**
  * Every valid column name for the model (attributes + system fields
  * added by traits like `id`, `uuid`, `created_at`). Useful for
  * constraining query builders that accept a `column` parameter.
  */
-export type InferColumnNames<T> = QueryInferColumnNames<T>;
+export type InferColumnNames<T> = AttributeKeys<Def<T>>
+  | SnakeCase<AttributeKeys<Def<T>>>
+  | PrimaryKey<Def<T>>
+  | BelongsToForeignKeyNames<Def<T>>
+  | keyof TraitFields<Def<T>>;
 /**
  * Attribute keys whose `type` is declared as `'number'` in the model
  * definition. Used to constrain aggregate methods (`sum`, `avg`,
@@ -84,4 +173,8 @@ export type InferColumnNames<T> = QueryInferColumnNames<T>;
  * `AttributeKeys<Def<T>>` here. Tighten by declaring `type: 'number'`
  * on the attribute spec when narrowing matters.
  */
-export type InferNumericColumns<T> = QueryInferNumericColumns<T>;
+export type InferNumericColumns<T> = {
+  [TKey in AttributeKeys<Def<T>>]: AttributeValue<DefinitionAttributes<Def<T>>[TKey]> extends number
+    ? TKey
+    : never
+}[AttributeKeys<Def<T>>];

package/dist/subquery.d.ts

@@ -1,4 +1,4 @@
-declare interface WhereCondition<T, V = any> {
+declare interface WhereCondition<T, V = unknown> {
   type: 'and' | 'or'
   method: 'where' | 'whereIn' | 'whereNull' | 'whereNotNull' | 'whereBetween' | 'whereExists'
   column: keyof T
@@ -10,13 +10,13 @@ declare interface WhereCondition<T, V = any> {
 }
 export type Operator = '=' | '<' | '>' | '<=' | '>=' | '<>' | '!=' | 'like' | 'not like' | 'in' | 'not in' | 'between' | 'not between' | 'is' | 'is not';
 export declare class SubqueryBuilder<T> {
-  where<V>(column: keyof T, ...args: [V] | [Operator, V]): void;
-  orWhere<V>(column: keyof T, ...args: [V] | [Operator, V]): void;
-  whereIn<V>(column: keyof T, values: V[]): void;
-  whereNotIn<V>(column: keyof T, values: V[]): void;
+  where<TKey extends keyof T>(column: TKey, ...args: [T[TKey]] | [Operator, T[TKey]]): void;
+  orWhere<TKey extends keyof T>(column: TKey, ...args: [T[TKey]] | [Operator, T[TKey]]): void;
+  whereIn<TKey extends keyof T>(column: TKey, values: T[TKey][]): void;
+  whereNotIn<TKey extends keyof T>(column: TKey, values: T[TKey][]): void;
   whereNull(column: keyof T): void;
   whereNotNull(column: keyof T): void;
-  whereBetween<V>(column: keyof T, range: [V, V]): void;
+  whereBetween<TKey extends keyof T>(column: TKey, range: [T[TKey], T[TKey]]): void;
   whereExists(callback: (query: SubqueryBuilder<T>) => void): void;
   getConditions(): WhereCondition<T>[];
 }

package/dist/transaction.d.ts

@@ -50,12 +50,12 @@ export declare function savepoint<T>(callback: (sp: TransactionHandle) => Promis
  * const user = await createUserWithProfile('Alice', 'Hello world')
  * ```
  */
-export declare function transactional<TArgs extends any[], R>(fn: (tx: TransactionHandle, ...args: TArgs) => Promise<R>, options?: TransactionOptions): (...args: TArgs) => Promise<R>;
+export declare function transactional<TArgs extends unknown[], R>(fn: (tx: TransactionHandle, ...args: TArgs) => Promise<R>, options?: TransactionOptions): (...args: TArgs) => Promise<R>;
 export declare interface TransactionOptions {
   retries?: number
   isolation?: 'read committed' | 'repeatable read' | 'serializable'
   readOnly?: boolean
-  onRollback?: (error: any) => void
+  onRollback?: (error: unknown) => void
   afterRollback?: () => void
 }
 /**

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/orm",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.368",
+  "version": "0.70.370",
   "description": "The Stacks ORM integration",
   "author": "Chris Breuer",
   "contributors": [
@@ -59,16 +59,17 @@
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
+    "typecheck:inference": "bun run build && (cd ../faker && bun run build) && (cd ../query-builder && bun run build) && (cd ../types && bun run build) && (cd ../validation && bun run build) && bun tsc -p tsconfig.type-tests.json",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/ts-validation": "^0.5.0",
-    "bun-query-builder": "^0.2.25"
+    "@stacksjs/ts-validation": "^0.5.3",
+    "bun-query-builder": "^0.2.28"
   },
   "devDependencies": {
-    "@stacksjs/config": "0.70.368",
+    "@stacksjs/config": "0.70.370",
     "better-dx": "^0.2.17",
-    "@stacksjs/query-builder": "0.70.368",
-    "@stacksjs/types": "0.70.368"
+    "@stacksjs/query-builder": "0.70.370",
+    "@stacksjs/types": "0.70.370"
   }
 }