@stacksjs/orm 0.72.6 → 0.72.8

package/dist/define-model.d.ts

@@ -188,11 +188,36 @@ declare type InferenceHint<TAttribute> = TAttribute extends { type: unknown } |
           ? object
           : { type: DefaultTypeToken<TAttribute> }
       : { type: ValidationInferenceRule<ValidationRuleOf<TAttribute>> }
+/**
+ * `required: false` is what makes the emitted column nullable, so it has to
+ * imply `nullable: true` for the inferred value type as well.
+ *
+ * Without this the two halves of a definition disagree. Value types come from
+ * the seed factory's return type, and a factory exists to produce a *useful*
+ * sample row, so optional columns are routinely written as
+ * `factory: () => new Date().toISOString()`. That inferred a bare `string`,
+ * which made `update({ nextPollAt: null })` a type error against a column the
+ * migration had already created as nullable. An explicit `nullable` on the
+ * attribute still wins, since it is the more specific declaration.
+ */
+declare type IsOptionalAttribute<TAttribute> = TAttribute extends { required: false } ? true : false;
+/** Covers attributes with no factory, where the validation rule drives the type. */
+declare type NullabilityOf<TAttribute> = TAttribute extends { nullable: unknown }
+  ? object
+  : IsOptionalAttribute<TAttribute> extends true ? { nullable: true } : object;
+/**
+ * Covers attributes that do have a factory, whose return type takes precedence
+ * over `nullable` when the value type is inferred.
+ */
+declare type FactoryValueOf<TAttribute> = IsOptionalAttribute<TAttribute> extends true
+  ? FactoryReturnOf<TAttribute> | null
+  : FactoryReturnOf<TAttribute>;
 declare type QueryAttribute<TAttribute> = Omit<TAttribute, 'factory'>
   & InferenceHint<TAttribute>
+  & NullabilityOf<TAttribute>
   & ([FactoryReturnOf<TAttribute>] extends [never]
     ? object
-    : { factory: (faker: BQBFaker) => FactoryReturnOf<TAttribute> });
+    : { factory: (faker: BQBFaker) => FactoryValueOf<TAttribute> });
 declare type QueryTraits<TDef extends ModelDefinition> = TDef extends { traits: infer TTraits }
   ? { traits: TTraits & NonNullable<BQBModelDefinition['traits']> }
   : { traits?: BQBModelDefinition['traits'] }

package/dist/index.d.ts

@@ -140,6 +140,22 @@ export declare const Transaction: ReturnType<typeof lazyModel<typeof import('../
 export declare const WaitlistProduct: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/commerce/WaitlistProduct').default>>;
 export declare const WaitlistRestaurant: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/commerce/WaitlistRestaurant').default>>;
 export declare const Websocket: ReturnType<typeof lazyModel<typeof import('../../../defaults/app/Models/realtime/Websocket').default>>;
+/**
+ * A model record seen only through `get(column)`.
+ *
+ * Normalizers, dashboard aggregators and report builders all take rows from
+ * more than one model and read a handful of shared columns by name. Typing
+ * that parameter as the model's own record ties the helper to one model;
+ * typing it as `{ get: (key: string) => unknown }` is WIDER than what any real
+ * record offers, and contravariance then makes every real record unassignable.
+ *
+ * Four copies of this interface had grown up in the dashboard scaffold - one
+ * each for jobs, kanban, analytics and deployments - all with the same
+ * hard-won `any`. This is that type, once.
+ */
+export declare interface ReadableRecord {
+  get: (key: any) => unknown
+}
 /**
  * Framework-default User row shape. Matches the attributes declared on
  * `storage/framework/defaults/app/Models/User.ts` plus the system

package/dist/model-types.d.ts

@@ -60,8 +60,16 @@ declare type AttributeValue<TAttribute> = TAttribute extends { readonly type: in
       ? TRule extends Validator<infer TValue> ? TValue : unknown
       : TAttribute extends { readonly default: infer TDefault } ? WidenDefault<TDefault>
         : unknown;
+/**
+ * An attribute is nullable when it says so outright, or when `required: false`
+ * marks it optional. The latter is what makes the generated column nullable, so
+ * the row type has to agree with the schema the migration emits.
+ */
+declare type IsNullableAttribute<TAttribute> = TAttribute extends { readonly nullable: true }
+  ? true
+  : TAttribute extends { readonly required: false } ? true : false;
 declare type DeclaredAttributes<TDef> = {
-  [TKey in AttributeKeys<TDef>]: DefinitionAttributes<TDef>[TKey] extends { readonly nullable: true }
+  [TKey in AttributeKeys<TDef>]: IsNullableAttribute<DefinitionAttributes<TDef>[TKey]> extends true
     ? AttributeValue<DefinitionAttributes<TDef>[TKey]> | null
     : AttributeValue<DefinitionAttributes<TDef>[TKey]>
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/orm",
   "type": "module",
   "sideEffects": false,
-  "version": "0.72.6",
+  "version": "0.72.8",
   "description": "The Stacks ORM integration",
   "author": "Chris Breuer",
   "contributors": [
@@ -64,12 +64,12 @@
   },
   "dependencies": {
     "@stacksjs/ts-validation": "^0.5.4",
-    "bun-query-builder": "^0.2.39"
+    "bun-query-builder": "^0.2.41"
   },
   "devDependencies": {
-    "@stacksjs/config": "0.72.6",
+    "@stacksjs/config": "0.72.8",
     "better-dx": "^0.2.23",
-    "@stacksjs/query-builder": "0.72.6",
-    "@stacksjs/types": "0.72.6"
+    "@stacksjs/query-builder": "0.72.8",
+    "@stacksjs/types": "0.72.8"
   }
 }