@stacksjs/orm 0.70.369 → 0.70.371

package/dist/batch-loader.d.ts

@@ -16,4 +16,8 @@
  * ```
  */
 // eslint-disable-next-line pickier/no-unused-vars
-export declare function batchLoad<T extends { findMany?: (ids: any[]) => Promise<any[]>, find?: (id: any) => Promise<any> }, K = number | string>(model: T, key: K): Promise<unknown>;
+export declare function batchLoad<TKey = number | string, TValue = Record<string, unknown>>(model: {
+    name?: string
+    findMany?: (ids: TKey[]) => Promise<TValue[]>
+    find?: (id: TKey) => Promise<TValue | undefined>
+  }, key: TKey): Promise<TValue | undefined>;

package/dist/define-model.d.ts

@@ -6,7 +6,10 @@ import { createSoftDeleteMethods } from './traits/soft-deletes';
 import { createTaggableMethods } from './traits/taggable';
 import { createTwoFactorMethods } from './traits/two-factor';
 import { type OrmModelDefinition as BQBModelDefinition, type OrmModelStatic } from '@stacksjs/query-builder';
+import type { ApiMiddleware } from '@stacksjs/types';
+import type { Faker } from '@stacksjs/faker';
 import type { InferRelationNames } from '@stacksjs/query-builder';
+import type { Validator } from '@stacksjs/validation';
 // Re-export types from bun-query-builder for convenience
 export type { ModelDefinition, InferRelationNames, ModelAttributes, InferModelAttributes, SystemFields, ColumnName, AttributeKeys, FillableKeys, HiddenKeys, ModelInstance, ModelQueryBuilder } from '@stacksjs/query-builder';
 /**
@@ -95,18 +98,12 @@ export declare interface StacksModelDefinition extends Omit<BQBModelDefinition,
     useApi?: boolean | {
       readonly uri?: string
       readonly routes?: readonly string[]
-      readonly middleware?: any
+      readonly middleware?: ApiMiddleware
     }
   } & Record<string, unknown>
   indexes?: Array<{ name: string, columns: string[], unique?: boolean, where?: string }>
   casts?: Record<string, CastType | CasterInterface>
-  attributes: {
-    [key: string]: {
-      factory?: (faker: any) => any
-      [key: string]: any
-    }
-  }
-  [key: string]: any
+  attributes: Record<string, StacksModelAttribute>
 }
 /**
  * Scout-style search index sync when `traits.useSearch` is set.
@@ -164,7 +161,46 @@ export declare interface TraitMethods {
  * the render layer.
  */
 export type CastType = 'string' | 'number' | 'boolean' | 'json' | 'datetime' | 'date' | 'array' | 'integer' | 'float';
+declare type BQBModelAttribute = BQBModelDefinition['attributes'][string];
+export type StacksModelAttribute = Omit<BQBModelAttribute, 'factory'> & {
+  factory?: (faker: Faker) => unknown
+}
 declare type ModelDefinition = StacksModelDefinition;
+declare type ValidationRuleOf<TAttribute> = TAttribute extends { validation: { rule: infer TRule } } ? TRule : never;
+declare type ValidationInferenceRule<TRule> = TRule extends Validator<number> ? 'number' : TRule;
+declare type BQBFaker = Parameters<NonNullable<BQBModelAttribute['factory']>>[0];
+declare type FactoryReturnOf<TAttribute> = TAttribute extends { factory: (...args: never[]) => infer TResult } ? TResult : never;
+declare type DefaultTypeToken<TAttribute> = TAttribute extends { default: infer TDefault }
+  ? TDefault extends string ? 'string'
+    : TDefault extends number ? 'number'
+      : TDefault extends boolean ? 'boolean'
+        : TDefault extends Date ? 'date'
+          : TDefault extends Record<string, unknown> ? 'json'
+            : never
+  : never;
+declare type InferenceHint<TAttribute> = TAttribute extends { type: unknown } | { factory: (...args: never[]) => unknown }
+  ? object
+  : [ValidationRuleOf<TAttribute>] extends [never]
+      ? [DefaultTypeToken<TAttribute>] extends [never]
+          ? object
+          : { type: DefaultTypeToken<TAttribute> }
+      : { type: ValidationInferenceRule<ValidationRuleOf<TAttribute>> }
+declare type QueryAttribute<TAttribute> = Omit<TAttribute, 'factory'>
+  & InferenceHint<TAttribute>
+  & ([FactoryReturnOf<TAttribute>] extends [never]
+    ? object
+    : { factory: (faker: BQBFaker) => FactoryReturnOf<TAttribute> });
+declare type QueryTraits<TDef extends ModelDefinition> = TDef extends { traits: infer TTraits }
+  ? { traits: TTraits & NonNullable<BQBModelDefinition['traits']> }
+  : { traits?: BQBModelDefinition['traits'] }
+declare type QueryDefinition<TDef extends ModelDefinition> = TDef
+  & {
+    attributes: { [TKey in keyof TDef['attributes']]: QueryAttribute<TDef['attributes'][TKey]> }
+  }
+  & QueryTraits<TDef>;
+declare type QueryModel<TDef extends ModelDefinition> = OrmModelStatic<QueryDefinition<TDef>>;
+declare type ModelWriteData<TDef extends ModelDefinition> = Parameters<QueryModel<TDef>['create']>[0];
+declare type ModelForceWriteData<TDef extends ModelDefinition> = Parameters<ReturnType<QueryModel<TDef>['make']>['forceFill']>[0];
 /**
  * Stacks-enhanced model definition.
  *
@@ -198,22 +234,23 @@ declare type ModelDefinition = StacksModelDefinition;
  *   name: 'Post',
  *   table: 'posts',
  *   attributes: {
- *     title: { type: 'string', fillable: true, validation: { rule: schema.string() } },
- *     views: { type: 'number', fillable: true, validation: { rule: schema.number() } },
+ *     title: { fillable: true, validation: { rule: schema.string() } },
+ *     views: { fillable: true, validation: { rule: schema.number() } },
  *   },
  *   belongsTo: ['Author'],
  *   hasMany: ['Tag', 'Category', 'Comment'],
  *   traits: { useTimestamps: true, useUuid: true },
- * } as const)
+ * })
  *
  * // Result: Post.where('title', 'test') — 'title' narrowed to valid columns
  * // Result: Post.with('author') — 'author' narrowed to valid relations
  * ```
  */
-export type StacksModelStatic<TDef extends ModelDefinition> = OrmModelStatic<TDef> & TDef & TraitMethods & {
-  update: (id: number | string, data: Record<string, unknown>) => ReturnType<OrmModelStatic<TDef>['find']>
-  forceUpdate: (id: number | string, data: Record<string, unknown>) => ReturnType<OrmModelStatic<TDef>['find']>
-  forceCreate: (data: Record<string, unknown>) => ReturnType<OrmModelStatic<TDef>['create']>
+export type StacksModelStatic<TDef extends ModelDefinition> = QueryModel<TDef> & TDef & TraitMethods & {
+  readonly [MODEL_DEFINITION]: TDef
+  update: (id: number | string, data: ModelWriteData<TDef>) => ReturnType<QueryModel<TDef>['find']>
+  forceUpdate: (id: number | string, data: ModelForceWriteData<TDef>) => ReturnType<QueryModel<TDef>['find']>
+  forceCreate: (data: ModelForceWriteData<TDef>) => ReturnType<QueryModel<TDef>['create']>
   delete: (id: number | string) => Promise<boolean>
   withoutEvents: <T>(fn: () => T | Promise<T>) => Promise<T>
   /** Run `fn` with declared `validation.rule`s suppressed (bulk imports, backfills). */

package/dist/index.d.ts

@@ -69,6 +69,9 @@ export declare const DriverPing: ReturnType<typeof lazyModel<typeof import('../.
 export declare const CampaignSend: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/CampaignSend').default>>;
 export declare const EmailList: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/EmailList').default>>;
 export declare const EmailListSubscriber: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/EmailListSubscriber').default>>;
+export declare const EmailIdempotency: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/EmailIdempotency').default>>;
+export declare const EmailSuppression: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/EmailSuppression').default>>;
+export declare const EmailWebhookEvent: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/EmailWebhookEvent').default>>;
 export declare const ErrorModel: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/Error').default>>;
 export declare const GiftCard: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/commerce/GiftCard').default>>;
 export declare const Label: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/Label').default>>;