uql-orm 0.24.2 → 0.24.3

package/dist/entity/decorator/members.d.ts

@@ -1,6 +1,17 @@
-import type { EntityGetter, FieldOptions, FieldType, RelationManyToManyOptions, RelationManyToOneOptions, RelationOneToManyOptions, RelationOneToOneOptions, TsTypeOf } from '../../type/index.js';
+import type { EntityGetter, FieldOptions, FieldType, IdValue, RelationManyToManyOptions, RelationManyToOneOptions, RelationOneToManyOptions, RelationOneToOneOptions, TsTypeOf } from '../../type/index.js';
 /** A member decorator that also constrains the property it may be applied to. */
 type MemberDecorator<V> = (value: undefined, context: ClassFieldDecoratorContext<unknown, V>) => void;
+/**
+ * The property type a set of field options describes, in the same order schema generation resolves the
+ * column: a declared `type` wins, and otherwise the column - and so the property - is the referenced
+ * primary key's own type. Which is what makes `@Field({ references: () => User })` on a `number`, where
+ * `User.id` is a `uuid`, a compile error rather than a column that disagrees with its property.
+ */
+type DeclaredValue<O> = O extends {
+    readonly type: infer T extends FieldType;
+} ? TsTypeOf<T> : O extends {
+    readonly references: EntityGetter<infer E>;
+} ? IdValue<E> : never;
 /**
  * Declares a persisted field.
  *
@@ -8,27 +19,22 @@ type MemberDecorator<V> = (value: undefined, context: ClassFieldDecoratorContext
  * which is what makes the now-mandatory `type` worth stating.
  *
  * @example `@Field({ type: String }) name?: string;`
- * @example `@Field({ references: () => Company }) companyId?: string;`
- */
-export declare function Field<T extends FieldType>(opts: FieldOptions & {
-    readonly type: T;
-}): MemberDecorator<TsTypeOf<T> | undefined>;
-/**
- * A foreign key may omit `type`: schema generation resolves it from the referenced primary key, so the
- * column picks up that key's `columnType`, length and chained references rather than a guess.
+ * @example `@Field({ references: () => User }) userId?: string;` (where `User.id` is a `uuid`)
  */
-export declare function Field(opts: FieldOptions & {
-    readonly references: EntityGetter;
-}): MemberDecorator<unknown>;
+export declare function Field<O extends FieldOptions<DeclaredValue<O>> & ({
+    type: FieldType;
+} | {
+    references: EntityGetter;
+})>(opts: O): MemberDecorator<DeclaredValue<O> | undefined>;
 /**
  * Declares the primary key, checked the same way as `@Field`.
  *
  * @example `@Id({ type: Number }) id?: number;`
  * @example `@Id({ type: 'uuid', onInsert: uuidv7 }) id?: string;`
  */
-export declare function Id<T extends FieldType>(opts: FieldOptions & {
-    readonly type: T;
-}): MemberDecorator<TsTypeOf<T> | undefined>;
+export declare function Id<O extends FieldOptions<DeclaredValue<O>> & {
+    type: FieldType;
+}>(opts: O): MemberDecorator<DeclaredValue<O> | undefined>;
 /**
  * `E` comes from the mandatory `entity` getter, so the context can insist the property really holds that
  * entity: `@ManyToOne({ entity: () => Other })` on a `Company` field stops compiling, and a to-many

package/dist/entity/decorator/members.js

@@ -1,4 +1,13 @@
 import { memberRegistrations } from './bag.js';
+/**
+ * Declares a persisted field.
+ *
+ * `@Field({ type: String })` on a `number` property is a compile error rather than a silent TEXT column,
+ * which is what makes the now-mandatory `type` worth stating.
+ *
+ * @example `@Field({ type: String }) name?: string;`
+ * @example `@Field({ references: () => User }) userId?: string;` (where `User.id` is a `uuid`)
+ */
 export function Field(opts) {
     return (_value, context) => {
         memberRegistrations(context.metadata).fields[String(context.name)] = opts;

package/dist/type/entity.d.ts

@@ -206,9 +206,11 @@ export type FieldType = StringConstructor | NumberConstructor | BooleanConstruct
  */
 export type TypeFor<V, T = NonNullable<V>> = IsJson<T> extends true ? JsonColumnType : IsJson<NonNullable<Unpacked<T>>> extends true ? JsonColumnType : T extends readonly number[] ? VectorColumnType : T extends string ? StringConstructor | StringColumnType : T extends number ? NumberConstructor | NumericColumnType : T extends bigint ? BigIntConstructor | NumericColumnType : T extends boolean ? BooleanConstructor | BooleanColumnType : T extends Date ? DateConstructor | DateColumnType : T extends Uint8Array ? BlobColumnType : FieldType;
 /**
- * Configurable options for a field
+ * Configurable options for a field, carrying `V`, the value the column holds: what a generator returns
+ * and what a default is has to be that value, checked the same way the declared `type` is. `Scalar` by
+ *  by default, for the places that handle a field without knowing which one it is.
  */
-export type FieldOptions = {
+export type FieldOptions<V = TsTypeOf<FieldType>> = {
     readonly name?: string;
     readonly isId?: true;
     readonly type?: FieldType;
@@ -238,8 +240,8 @@ export type FieldOptions = {
     readonly virtual?: QueryRaw;
     readonly updatable?: boolean;
     readonly eager?: boolean;
-    readonly onInsert?: OnFieldCallback;
-    readonly onUpdate?: OnFieldCallback;
+    readonly onInsert?: OnFieldCallback<V>;
+    readonly onUpdate?: OnFieldCallback<V>;
     /**
      * Marks this field as the soft-delete field. Its presence makes the entity "soft deletable":
      * a `delete` becomes an `UPDATE` that stamps this field instead of removing the row, and reads
@@ -251,7 +253,7 @@ export type FieldOptions = {
      * @example `@Field({ softDelete: true }) deletedAt?: Date;`
      * @example `@Field({ softDelete: () => Date.now() }) deletedAt?: number;`
      */
-    readonly softDelete?: OnFieldCallback;
+    readonly softDelete?: true | OnFieldCallback<V>;
     /**
      * SQL column type for migrations. If not specified, inferred from TypeScript type.
      */
@@ -279,7 +281,7 @@ export type FieldOptions = {
     /**
      * Default value for the column
      */
-    readonly defaultValue?: Scalar | Record<string, unknown>;
+    readonly defaultValue?: V | Record<string, unknown>;
     /**
      * Whether the column is auto-incrementing (for integer IDs).
      */
@@ -293,7 +295,7 @@ export type FieldOptions = {
      */
     readonly comment?: string;
 };
-export type OnFieldCallback = Scalar | QueryRaw | (() => Scalar | QueryRaw);
+export type OnFieldCallback<V = TsTypeOf<FieldType>> = V | QueryRaw | (() => V | QueryRaw);
 /**
  * The TypeScript types a field may be declared as, given the `type` it registers: the inverse of
  * {@link TypeFor}.
@@ -316,9 +318,9 @@ export type TsTypeOf<T> = T extends StringConstructor ? string : T extends Numbe
  * `@Field({ references: () => Company })` would silently downgrade a `uuid` key to TEXT on every
  * column pointing at it.
  */
-export type FieldOptionsFor<V> = (FieldOptions & {
+export type FieldOptionsFor<V> = (FieldOptions<NonNullable<V>> & {
     readonly type: TypeFor<V>;
-}) | (FieldOptions & {
+}) | (FieldOptions<NonNullable<V>> & {
     readonly references: EntityGetter;
     readonly type?: TypeFor<V>;
 });

package/dist/util/dialect.util.d.ts

@@ -14,12 +14,20 @@ export declare function filterFieldKeys<E>(meta: EntityMeta<E>, payload: E, call
  * chunk-size estimate inspects the raw payload).
  */
 export declare function getInsertFieldKeys<E>(meta: EntityMeta<E>, payloads: E[]): FieldKey<E>[];
-export declare function getFieldCallbackValue(val: OnFieldCallback): QueryRaw | import("../type/utility.js").Scalar;
+export declare function getFieldCallbackValue(val: OnFieldCallback): string | number | bigint | boolean | Date | QueryRaw | readonly {
+    readonly __json?: never;
+}[] | readonly number[] | Uint8Array<ArrayBufferLike> | {
+    readonly __json?: never;
+};
 /**
  * Resolves the value stamped on the soft-delete field when deleting a row.
  * `true` stamps the current timestamp (`new Date()`); any other marker is an {@link OnFieldCallback}.
  */
-export declare function getSoftDeleteValue(field: FieldOptions): QueryRaw | import("../type/utility.js").Scalar;
+export declare function getSoftDeleteValue(field: FieldOptions): string | number | bigint | boolean | Date | QueryRaw | readonly {
+    readonly __json?: never;
+}[] | readonly number[] | Uint8Array<ArrayBufferLike> | {
+    readonly __json?: never;
+};
 export declare function fillOnFields<E>(meta: EntityMeta<E>, payload: E | E[], callbackKey: CallbackKey): E[];
 /**
  * The relation keys present in `payload` whose cascade configuration allows `action`. Only

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "Extremely fast, type-safe TypeScript ORM - one API for every database",
   "license": "MIT",
-  "version": "0.24.2",
+  "version": "0.24.3",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -198,5 +198,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "419ba75dc2e856f6b8030fa0a6fed3e5c7940de1"
+  "gitHead": "4301613bcab77a626513197f1e815f972aa21bba"
 }