@tailor-platform/sdk 2.0.0-next.4 → 2.0.0-next.5

package/dist/configure/services/tailordb/schema.d.mts

@@ -1,13 +1,12 @@
+import { FieldOptions, FieldOutput, FieldValidateInput, TailorFieldType, TailorToTs } from "../../types/field.types.mjs";
 import { InferredAttributes, TailorPrincipal } from "../../../runtime/types.mjs";
 import { InferFieldsOutput, TypeLevelError, output } from "../../../types/helpers.mjs";
-import { FieldOptions, FieldOutput, FieldValidateInput, TailorFieldType, TailorToTs, Validators } from "../../types/field.types.mjs";
-import { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeNestedDBFields, Hook, Hooks, IndexDef, RelationType, SerialConfig, TailorDBField as TailorDBField$1, TailorDBType as TailorDBType$1, TypeFeatures } from "./types.mjs";
+import { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeDefaultedDBFields, ExcludeHookedDBFields, ExcludeNestedDBFields, Hook, IndexDef, RelationType, SerialConfig, TailorDBField as TailorDBField$1, TailorDBType as TailorDBType$1, TypeFeatures, TypeHook, TypeValidateFn } from "./types.mjs";
 import { AllowedValues, AllowedValuesOutput } from "../../types/field.mjs";
 import { FieldParseArgs, FieldParseInternalArgs } from "../../types/field-runtime.mjs";
 import { PluginConfigs } from "../../../plugin/types.mjs";
 import { TailorTypeGqlPermission, TailorTypePermission } from "./permission.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/configure/services/tailordb/schema.d.ts
 type AnyBuilderMethod = any;
 type TailorAnyDBField = Omit<TailorDBField$1<AnyBuilderMethod, AnyBuilderMethod>, "fields"> & {
@@ -21,12 +20,13 @@ type TailorAnyDBField = Omit<TailorDBField$1<AnyBuilderMethod, AnyBuilderMethod>
   index: AnyBuilderMethod;
   unique: AnyBuilderMethod;
   vector: AnyBuilderMethod;
+  default: AnyBuilderMethod;
   hooks: AnyBuilderMethod;
   validate: AnyBuilderMethod;
   serial: AnyBuilderMethod;
   clone: AnyBuilderMethod;
 };
-type TailorAnyDBType = TailorDBType<any, any>;
+type TailorAnyDBType = TailorDBType<any, any, any>;
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type DBFieldTypeNameMethod<Defined extends DefinedDBFieldMetadata> = IsAny<Defined> extends true ? TypeLevelError<string> : TypeLevelError<"typeName cannot be used on TailorDB fields">;
 type WithDBFieldDescription<Defined> = Defined & {
@@ -67,6 +67,9 @@ type WithDBFieldHooks<Defined, H> = Defined & {
   };
   serial: false;
 };
+type WithDBFieldDefault<Defined> = Defined & {
+  default: true;
+};
 type WithDBFieldValidate<Defined> = Defined & {
   validate: true;
 };
@@ -96,6 +99,30 @@ type DBFieldCloneOutput<Output, NewOpt extends FieldOptions> = NewOpt extends {
 } ? DBFieldCloneArrayOutput<Output, NewOpt> | null : NewOpt extends {
   optional: false;
 } ? DBFieldCloneArrayOutput<Output, NewOpt> : null extends Output ? DBFieldCloneArrayOutput<Output, NewOpt> | null : DBFieldCloneArrayOutput<Output, NewOpt>;
+type DBFieldCloneOptions<Defined extends DefinedDBFieldMetadata> = Omit<FieldOptions, "array"> & {
+  array?: Defined extends {
+    validate: unknown;
+  } ? Defined["array"] : boolean;
+};
+type InvalidValidatedArrayCloneKeys<Fields extends Record<string, TailorAnyDBField>, K extends keyof Fields, Opt extends FieldOptions> = Opt extends {
+  array: infer ArrayOption;
+} ? { [P in K]: Fields[P] extends TailorDBField<infer Defined, infer _Output> ? Defined extends {
+  validate: unknown;
+} ? ArrayOption extends Defined["array"] ? never : P : never : never; }[K] : never;
+type DBFieldsCloneOptionsGuard<Fields extends Record<string, TailorAnyDBField>, K extends keyof Fields, Opt extends FieldOptions> = [InvalidValidatedArrayCloneKeys<Fields, K, Opt>] extends [never] ? unknown : TypeLevelError<"array cannot be changed on fields with custom validation">;
+type DefinedDBTypeMetadata = {
+  hooks?: true;
+  validate?: true;
+  features?: true;
+  indexes?: true;
+  files?: true;
+  permission?: true;
+  gqlPermission?: true;
+  description?: true;
+};
+type WithDBTypeMetadata<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata> = Defined & Record<Key, true>;
+type DBTypeDuplicateInputGuard<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata, Input, Message extends string> = IsAny<Defined> extends true ? Input : Defined extends Record<Key, unknown> ? TypeLevelError<Message> : Input;
+type DBTypeDuplicateRestGuard<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata, Input extends unknown[], Message extends string> = IsAny<Defined> extends true ? Input : Defined extends Record<Key, unknown> ? [TypeLevelError<Message>, ...TypeLevelError<Message>[]] : Input;
 type FileKeyConflictError<Fields extends Record<string, TailorAnyDBField>, User extends object> = Partial<Record<keyof output<TailorDBType<Fields, User>> & string, TypeLevelError<"file keys cannot use existing field names">>>;
 type DBFieldDescriptionFn<Defined extends DefinedDBFieldMetadata, Output> = (description: string) => TailorDBField<WithDBFieldDescription<Defined>, Output>;
 type DBFieldRelationFn<Defined extends DefinedDBFieldMetadata, Output> = {
@@ -105,7 +132,9 @@ type DBFieldRelationFn<Defined extends DefinedDBFieldMetadata, Output> = {
 type DBFieldIndexFn<Defined extends DefinedDBFieldMetadata, Output> = () => TailorDBField<WithDBFieldIndex<Defined>, Output>;
 type DBFieldUniqueFn<Defined extends DefinedDBFieldMetadata, Output> = () => TailorDBField<WithDBFieldUnique<Defined>, Output>;
 type DBFieldVectorFn<Defined extends DefinedDBFieldMetadata, Output> = () => TailorDBField<WithDBFieldVector<Defined>, Output>;
-type DBFieldHooksFn<Defined extends DefinedDBFieldMetadata, Output> = <const H extends Hook<unknown, Output>>(hooks: H) => TailorDBField<WithDBFieldHooks<Defined, H>, Output>;
+type DBFieldHooksFn<Defined extends DefinedDBFieldMetadata, Output> = <const H extends Hook<Output, Defined extends {
+  default: true;
+} ? Output | null | undefined : Output>>(hooks: H) => TailorDBField<WithDBFieldHooks<Defined, H>, Output>;
 type DBFieldValidateFn<Defined extends DefinedDBFieldMetadata, Output> = (...validate: FieldValidateInput<Output>[]) => TailorDBField<WithDBFieldValidate<Defined>, Output>;
 type DBFieldSerialFn<Defined extends DefinedDBFieldMetadata, Output> = (config: SerialConfig<Defined["type"] & ("integer" | "string")>) => TailorDBField<WithDBFieldSerial<Defined>, Output>;
 type DBFieldDescriptionMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldDescriptionFn<Defined, Output> : Defined extends {
@@ -114,16 +143,13 @@ type DBFieldDescriptionMethod<Defined extends DefinedDBFieldMetadata, Output> =
 type DBFieldRelationMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldRelationFn<Defined, Output> : Defined extends {
   relation: unknown;
 } ? TypeLevelError<".relation() has already been set"> : DBFieldRelationFn<Defined, Output>;
+type DBFieldArrayCheck<A extends boolean, Ok, Msg extends string> = A extends true ? TypeLevelError<Msg> : Ok;
 type DBFieldIndexMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldIndexFn<Defined, Output> : Defined extends {
   index: unknown;
-} ? TypeLevelError<".index() has already been set"> : boolean extends Defined["array"] ? DBFieldIndexFn<Defined, Output> | TypeLevelError<"index cannot be set on array fields"> : Defined extends {
-  array: true;
-} ? TypeLevelError<"index cannot be set on array fields"> : DBFieldIndexFn<Defined, Output>;
+} ? TypeLevelError<".index() has already been set"> : DBFieldArrayCheck<Defined["array"], DBFieldIndexFn<Defined, Output>, "index cannot be set on array fields">;
 type DBFieldUniqueMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldUniqueFn<Defined, Output> : Defined extends {
   unique: unknown;
-} ? TypeLevelError<".unique() has already been set"> : boolean extends Defined["array"] ? DBFieldUniqueFn<Defined, Output> | TypeLevelError<"unique cannot be set on array fields"> : Defined extends {
-  array: true;
-} ? TypeLevelError<"unique cannot be set on array fields"> : DBFieldUniqueFn<Defined, Output>;
+} ? TypeLevelError<".unique() has already been set"> : DBFieldArrayCheck<Defined["array"], DBFieldUniqueFn<Defined, Output>, "unique cannot be set on array fields">;
 type DBFieldVectorMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldVectorFn<Defined, Output> : Defined extends {
   vector: unknown;
 } ? TypeLevelError<".vector() has already been set"> : Defined extends {
@@ -155,6 +181,14 @@ type DBFieldSerialMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny
   type: "integer" | "string";
   array: false;
 } ? DBFieldSerialFn<Defined, Output> : TypeLevelError<"serial can only be set on non-array integer or string fields">;
+type DBFieldDefaultFn<Defined extends DefinedDBFieldMetadata, Output> = (value: Output extends null ? NonNullable<Output> : Output) => TailorDBField<WithDBFieldDefault<Defined>, Output>;
+type DBFieldDefaultMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldDefaultFn<Defined, Output> : Defined extends {
+  default: unknown;
+} ? TypeLevelError<".default() has already been set"> : Defined extends {
+  type: "nested";
+} ? TypeLevelError<"default cannot be set on nested type fields"> : Defined extends {
+  serial: true;
+} ? TypeLevelError<"default cannot be set on serial fields"> : null extends Output ? TypeLevelError<"default cannot be set on optional fields"> : DBFieldDefaultFn<Defined, Output>;
 /**
  * Full TailorDBField interface with builder methods.
  * Extends the minimal structural interface from types/ with fluent API methods.
@@ -196,12 +230,24 @@ interface TailorDBField<Defined extends DefinedDBFieldMetadata = DefinedDBFieldM
    * Enable vector search on the field (string type only)
    */
   vector: DBFieldVectorMethod<Defined, Output>;
+  /**
+   * Set a default value for the field on create. When the field is required,
+   * this makes it optional in the Create input — the default fills in when
+   * no value (or a nullish hook result) is provided.
+   *
+   * For datetime/date/time fields, pass `"now"` to use the operation timestamp.
+   */
+  default: DBFieldDefaultMethod<Defined, Output>;
   /**
    * Add hooks for create/update operations on this field.
    */
   hooks: DBFieldHooksMethod<Defined, Output>;
   /**
    * Add validation functions to the field.
+   *
+   * Validators receive `{ value, data, user }` and run after hooks and
+   * built-in type validation; they are skipped when built-in validation
+   * fails. For array fields, `value` is the complete array.
    */
   validate: DBFieldValidateMethod<Defined, Output>;
   /**
@@ -209,30 +255,31 @@ interface TailorDBField<Defined extends DefinedDBFieldMetadata = DefinedDBFieldM
    */
   serial: DBFieldSerialMethod<Defined, Output>;
   /**
-   * Clone the field with optional overrides for field options
+   * Clone the field with optional overrides for field options.
+   * The `array` option cannot change on fields with custom validation.
    */
-  clone<const NewOpt extends FieldOptions>(options?: NewOpt): TailorDBField<WithDBFieldCloneOptions<Defined, NewOpt>, DBFieldCloneOutput<Output, NewOpt>>;
+  clone<const NewOpt extends DBFieldCloneOptions<Defined>>(options?: NewOpt): TailorDBField<WithDBFieldCloneOptions<Defined, NewOpt>, DBFieldCloneOutput<Output, NewOpt>>;
 }
 /**
  * Full TailorDBType interface with builder methods.
  * Extends the minimal structural interface from types/ with fluent API methods.
  */
-interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes> extends TailorDBType$1<Fields, User> {
+interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes, Defined extends DefinedDBTypeMetadata = any> extends TailorDBType$1<Fields, User> {
   _description?: string;
-  hooks(hooks: Hooks<Fields>): TailorDBType<Fields, User>;
-  validate(validators: Validators<Fields>): TailorDBType<Fields, User>;
-  features(features: Omit<TypeFeatures, "pluralForm">): TailorDBType<Fields, User>;
-  indexes(...indexes: IndexDef<TailorDBType<Fields, User>>[]): TailorDBType<Fields, User>;
-  files<const F extends string>(files: Record<F, string> & FileKeyConflictError<Fields, User>): TailorDBType<Fields, User>;
-  permission<U extends object = User, P extends TailorTypePermission<U, output<TailorDBType<Fields, User>>> = TailorTypePermission<U, output<TailorDBType<Fields, User>>>>(permission: P): TailorDBType<Fields, U>;
-  gqlPermission<U extends object = User, P extends TailorTypeGqlPermission<U> = TailorTypeGqlPermission<U>>(permission: P): TailorDBType<Fields, U>;
-  description(description: string): TailorDBType<Fields, User>;
+  hooks(hook: DBTypeDuplicateInputGuard<Defined, "hooks", TypeHook<Fields>, ".hooks() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "hooks">>;
+  validate(fn: DBTypeDuplicateInputGuard<Defined, "validate", TypeValidateFn<Fields>, ".validate() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "validate">>;
+  features(features: DBTypeDuplicateInputGuard<Defined, "features", Omit<TypeFeatures, "pluralForm">, ".features() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "features">>;
+  indexes(...indexes: DBTypeDuplicateRestGuard<Defined, "indexes", IndexDef<TailorDBType<Fields, User, Defined>>[], ".indexes() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "indexes">>;
+  files<const F extends string>(files: DBTypeDuplicateInputGuard<Defined, "files", Record<F, string> & FileKeyConflictError<Fields, User>, ".files() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "files">>;
+  permission<U extends object = User, P extends TailorTypePermission<U, output<TailorDBType<Fields, User, Defined>>> = TailorTypePermission<U, output<TailorDBType<Fields, User, Defined>>>>(permission: DBTypeDuplicateInputGuard<Defined, "permission", P, ".permission() has already been set">): TailorDBType<Fields, U, WithDBTypeMetadata<Defined, "permission">>;
+  gqlPermission<U extends object = User, P extends TailorTypeGqlPermission<U> = TailorTypeGqlPermission<U>>(permission: DBTypeDuplicateInputGuard<Defined, "gqlPermission", P, ".gqlPermission() has already been set">): TailorDBType<Fields, U, WithDBTypeMetadata<Defined, "gqlPermission">>;
+  description(description: DBTypeDuplicateInputGuard<Defined, "description", string, ".description() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "description">>;
   pickFields<K extends keyof Fields>(keys: K[]): Pick<Fields, K>;
-  pickFields<K extends keyof Fields, const Opt extends FieldOptions>(keys: K[], options: Opt): { [P in K]: Fields[P] extends TailorDBField<infer D, infer O> ? TailorDBField<WithDBFieldCloneOptions<D, Opt>, DBFieldCloneOutput<O, Opt>> : never };
+  pickFields<K extends keyof Fields, const Opt extends FieldOptions>(keys: K[], options: Opt & DBFieldsCloneOptionsGuard<Fields, K, Opt>): { [P in K]: Fields[P] extends TailorDBField<infer D, infer O> ? TailorDBField<WithDBFieldCloneOptions<D, Opt>, DBFieldCloneOutput<O, Opt>> : never; };
   omitFields<K extends keyof Fields>(keys: K[]): Omit<Fields, K>;
-  plugin<P extends keyof PluginConfigs<keyof Fields & string>>(config: { [K in P]: PluginConfigs<keyof Fields & string>[K] }): TailorDBType<Fields, User>;
+  plugin<P extends keyof PluginConfigs<keyof Fields & string>>(config: { [K in P]: PluginConfigs<keyof Fields & string>[K]; }): TailorDBType<Fields, User, Defined>;
 }
-type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes> = TailorDBType<Fields, User>;
+type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes, Defined extends DefinedDBTypeMetadata = any> = TailorDBType<Fields, User, Defined>;
 interface RelationConfig<S extends RelationType, T extends TailorDBType> {
   type: S;
   toward: {
@@ -358,7 +405,7 @@ declare function _enum<const V extends AllowedValues, const Opt extends FieldOpt
  * @example db.object({ street: db.string(), city: db.string(), zip: db.string() })
  * @example db.object({ name: db.string() }, { optional: true })
  */
-declare function object<const F extends Record<string, TailorAnyDBField> & ExcludeNestedDBFields<F>, const Opt extends FieldOptions>(fields: F, options?: Opt): TailorDBField<{
+declare function object<const F extends Record<string, TailorAnyDBField> & ExcludeNestedDBFields<F> & ExcludeHookedDBFields<F> & ExcludeDefaultedDBFields<F>, const Opt extends FieldOptions>(fields: F, options?: Opt): TailorDBField<{
   type: "nested";
   array: Opt extends {
     array: true;
@@ -368,9 +415,9 @@ declare const idField: TailorDBFieldInstance<"uuid", FieldOptions, string>;
 type idField = typeof idField;
 type DBTable<F extends {
   id?: never;
-} & Record<string, TailorAnyDBField>> = TailorDBInstance<{
+} & Record<string, TailorAnyDBField>, Defined extends DefinedDBTypeMetadata = DefinedDBTypeMetadata> = TailorDBInstance<{
   id: idField;
-} & F>;
+} & F, InferredAttributes, Defined>;
 /**
  * Creates a new database table with the specified fields.
  * An `id` field (UUID) is automatically added to every table.
@@ -401,7 +448,7 @@ declare function dbTable<const F extends {
  */
 declare function dbTable<const F extends {
   id?: never;
-} & Record<string, TailorAnyDBField>>(name: string | [string, string], description: string, fields: F): DBTable<F>;
+} & Record<string, TailorAnyDBField>>(name: string | [string, string], description: string, fields: F): DBTable<F, WithDBTypeMetadata<DefinedDBTypeMetadata, "description">>;
 /** TailorDB schema builder utilities for defining tables and fields. */
 declare const db: {
   table: typeof dbTable;
@@ -418,10 +465,9 @@ declare const db: {
   object: typeof object;
   fields: {
     /**
-     * Creates standard timestamp fields (createdAt, updatedAt) with auto-hooks.
-     * createdAt and updatedAt are set on create.
-     * User-specified timestamp values are respected when provided (e.g. seeding
-     * historical records); the current time is used only when the value is omitted.
+     * Creates standard timestamp fields (createdAt, updatedAt) with automatic defaults.
+     * Both fields default to the current time on create. updatedAt is also refreshed on update.
+     * User-specified values are respected when provided (e.g. seeding historical records).
      * @returns An object with createdAt and updatedAt fields
      * @example
      * const model = db.table("Model", {
@@ -430,24 +476,14 @@ declare const db: {
      * });
      */
     timestamps: () => {
-      createdAt: TailorDBField<WithDBFieldDescription<WithDBFieldHooks<DBFieldDefined<"datetime", FieldOptions>, {
-        readonly create: ({
-          value
-        }: {
-          value: string | Date | null;
-          data: unknown;
-          invoker: TailorPrincipal | null;
-        }) => string | Date;
-      }>>, string | Date>;
-      updatedAt: TailorDBField<WithDBFieldDescription<WithDBFieldHooks<DBFieldDefined<"datetime", FieldOptions>, {
-        readonly create: ({
-          value
-        }: {
-          value: string | Date | null;
-          data: unknown;
+      createdAt: TailorDBField<WithDBFieldDescription<WithDBFieldDefault<DBFieldDefined<"datetime", FieldOptions>>>, string | Date>;
+      updatedAt: TailorDBField<WithDBFieldDescription<WithDBFieldHooks<WithDBFieldDefault<DBFieldDefined<"datetime", FieldOptions>>, {
+        readonly update: ({ input, now }: {
+          input: string | Date | null;
+          oldValue: string | Date;
           invoker: TailorPrincipal | null;
+          now: Date;
         }) => string | Date;
-        readonly update: () => Date;
       }>>, string | Date>;
     };
   };

package/dist/configure/services/tailordb/types.d.mts

@@ -1,9 +1,7 @@
+import { DefinedFieldMetadata, FieldMetadata, TailorField, TailorFieldType } from "../../types/field.types.mjs";
 import { InferredAttributes, TailorPrincipal } from "../../../runtime/types.mjs";
-import { InferFieldsOutput, Prettify, output } from "../../../types/helpers.mjs";
-import { DefinedFieldMetadata, FieldMetadata, TailorField } from "../../types/field.types.mjs";
+import { DeepReadonly, InferFieldsOutput, Prettify, output } from "../../../types/helpers.mjs";
 import { DBFieldMetadata as DBFieldMetadata$1, GqlOperationsInput, RawPermissions, TailorDBServiceConfigInput } from "../../../types/tailordb.generated.mjs";
-import { NonEmptyObject } from "type-fest";
-
 //#region src/configure/services/tailordb/types.d.ts
 type SerialConfig<T extends "string" | "integer" = "string" | "integer"> = Prettify<{
   start: number;
@@ -23,6 +21,7 @@ interface DBFieldMetadata extends FieldMetadata {
   serial?: SerialConfig;
   relation?: boolean;
   scale?: number;
+  default?: unknown;
 }
 interface DefinedDBFieldMetadata extends DefinedFieldMetadata {
   index?: boolean;
@@ -37,6 +36,7 @@ interface DefinedDBFieldMetadata extends DefinedFieldMetadata {
   };
   serial?: boolean;
   relation?: boolean;
+  default?: boolean;
 }
 type GqlOperationsConfig = GqlOperationsInput;
 interface RawRelationConfig {
@@ -64,6 +64,11 @@ interface TailorDBTypeMetadata {
     fields: string[];
     unique?: boolean;
   }>;
+  typeHook?: {
+    create?: Function;
+    update?: Function;
+  };
+  typeValidate?: Function;
 }
 /**
  * Minimal structural interface for TailorDBField.
@@ -91,24 +96,68 @@ interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, Us
 }
 type TailorAnyDBType = TailorDBType<any, any>;
 type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes> = TailorDBType<Fields, User>;
-type HookFn<TValue, TData, TReturn> = (args: {
-  value: TValue;
-  data: TData extends Record<string, unknown> ? { readonly [K in keyof TData]?: TData[K] | null | undefined } : unknown;
+type HookArgs<TData> = TData extends Record<string, unknown> ? { readonly [K in keyof TData]?: DeepReadonly<TData[K]> | null | undefined; } : unknown;
+type CreateHookFn<TValue, TReturn> = (args: {
+  input: TValue;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => TReturn;
+type UpdateHookFn<TValue, TReturn> = (args: {
+  input: TValue;
+  oldValue: TReturn;
   invoker: TailorPrincipal | null;
+  now: Date;
 }) => TReturn;
-type Hook<TData, TReturn> = {
-  create?: HookFn<TReturn | null, TData, TReturn>;
-  update?: HookFn<TReturn | null, TData, TReturn>;
+type Hook<TReturn, TCreateReturn = TReturn> = {
+  create?: CreateHookFn<TReturn | null, TCreateReturn>;
+  update?: UpdateHookFn<TReturn | null, TReturn>;
+};
+type DotJoin<A extends string, B extends string> = A extends "" ? B : `${A}.${B}`;
+type DottedPaths<T, Prefix extends string = ""> = string extends keyof T ? string : T extends readonly (infer E)[] ? E extends Record<string, unknown> ? { [K in keyof E & string]: `${Prefix}[${number}].${K}` | DottedPaths<NonNullable<E[K]>, `${Prefix}[${number}].${K}`>; }[keyof E & string] : never : T extends Record<string, unknown> ? { [K in keyof T & string]: DotJoin<Prefix, K> | DottedPaths<NonNullable<T[K]>, DotJoin<Prefix, K>>; }[keyof T & string] : never;
+type TypeValidateFn<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]>; }> = (args: {
+  newRecord: DeepReadonly<TData>;
+  oldRecord: DeepReadonly<TData> | null;
+  invoker: TailorPrincipal | null;
+}, issues: <P extends DottedPaths<Omit<TData, "id">>>(field: P, message: string) => void) => void;
+type TypeCreateHookFn<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]>; }> = (args: {
+  input: DeepReadonly<TData>;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => { [K in Exclude<keyof TData & string, "id">]?: TData[K] | null; };
+type TypeUpdateHookFn<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]>; }> = (args: {
+  input: HookArgs<TData>;
+  oldRecord: DeepReadonly<TData>;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => { [K in Exclude<keyof TData & string, "id">]?: TData[K] | null; };
+type TypeHook<F extends Record<string, TailorAnyDBField>> = {
+  create?: TypeCreateHookFn<F>;
+  update?: TypeUpdateHookFn<F>;
 };
-type Hooks<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]> }> = NonEmptyObject<{ [K in Exclude<keyof F, "id"> as F[K]["_defined"] extends {
-  hooks: unknown;
-} ? never : F[K]["_defined"] extends {
-  type: "nested";
-} ? never : K]?: Hook<TData, output<F[K]>> }>;
 type ExcludeNestedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
   type: "nested";
   array: boolean;
-}, any> ? never : T[K] };
+}, any> ? never : T[K]; };
+type ExcludeHookedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: TailorFieldType;
+  array: boolean;
+  hooks: {
+    create: true;
+    update: boolean;
+  };
+}, any> ? never : T[K] extends TailorDBField<{
+  type: TailorFieldType;
+  array: boolean;
+  hooks: {
+    create: boolean;
+    update: true;
+  };
+}, any> ? never : T[K]; };
+type ExcludeDefaultedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: TailorFieldType;
+  array: boolean;
+  default: true;
+}, any> ? never : T[K]; };
 interface TypeFeatures {
   pluralForm?: string;
   aggregation?: true;
@@ -146,4 +195,4 @@ type TailorDBServiceInput = {
   [namespace: string]: TailorDBServiceConfigInput | TailorDBExternalConfig;
 };
 //#endregion
-export { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeNestedDBFields, GqlOperationsConfig, Hook, Hooks, IndexDef, PluginAttachment, RawRelationConfig, RelationType, SerialConfig, TailorAnyDBField, TailorAnyDBType, TailorDBExternalConfig, TailorDBField, TailorDBInstance, TailorDBServiceInput, TailorDBType, TailorDBTypeMetadata, TypeFeatures };
+export { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeDefaultedDBFields, ExcludeHookedDBFields, ExcludeNestedDBFields, GqlOperationsConfig, Hook, IndexDef, PluginAttachment, RawRelationConfig, RelationType, SerialConfig, TailorAnyDBField, TailorAnyDBType, TailorDBExternalConfig, TailorDBField, TailorDBInstance, TailorDBServiceInput, TailorDBType, TailorDBTypeMetadata, TypeFeatures, TypeHook, TypeValidateFn };

package/dist/configure/services/workflow/execution-policy.d.mts

@@ -1,5 +1,4 @@
 import { ExecutionPolicyConcurrency, ExecutionPolicyDefInput, ExecutionPolicyExactInstance, ExecutionPolicyGroupOptions, ExecutionPolicyInstance, ExecutionPolicyWildcardInstance, ResolvedExecutionPolicyInstance } from "./execution-policy.types.mjs";
-
 //#region src/configure/services/workflow/execution-policy.d.ts
 type ResolveKey<Def, Fallback extends string> = Def extends {
   key: infer K extends string;

package/dist/configure/services/workflow/execution-policy.types.d.mts

@@ -1,5 +1,4 @@
 import { ExecutionPolicyKey } from "../../../runtime/workflow.mjs";
-
 //#region src/configure/services/workflow/execution-policy.types.d.ts
 /**
  * Optional per-key concurrency cap applied to job function dispatches that

package/dist/configure/services/workflow/index.d.mts

@@ -5,4 +5,5 @@ import { WorkflowJob, WorkflowJobContext, createWorkflowJob } from "./job.mjs";
 import { Workflow, WorkflowConfig, createWorkflow } from "./workflow.mjs";
 import { defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy } from "./execution-policy.mjs";
 import { WaitPointInstance, createWaitPoint, createWaitPoints } from "./wait-point.mjs";
+import "./types.mjs";
 export { type ConcurrencyPolicy, type ExecutionPolicyConcurrency, type ExecutionPolicyDefInput, type ExecutionPolicyExactInstance, type ExecutionPolicyGroupOptions, type ExecutionPolicyInstance, type ExecutionPolicyWildcardInstance, type ResolvedExecutionPolicyInstance, type RetryPolicy, WaitPointInstance, Workflow, WorkflowConfig, WorkflowJob, WorkflowJobContext, type WorkflowServiceConfig, type WorkflowServiceInput, createWaitPoint, createWaitPoints, createWorkflow, createWorkflowJob, defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy };

package/dist/configure/services/workflow/job.d.mts

@@ -1,7 +1,6 @@
 import { TailorEnv, TailorPrincipal } from "../../../runtime/types.mjs";
 import { JsonCompatible, TypeLevelError } from "../../../types/helpers.mjs";
 import { TriggerJobFunctionOptions } from "../../../runtime/workflow.mjs";
-
 //#region src/configure/services/workflow/job.d.ts
 /**
  * Context object passed as the second argument to workflow job body functions.

package/dist/configure/services/workflow/wait-point.d.mts

@@ -1,5 +1,4 @@
 import { JsonCompatible, TypeLevelError } from "../../../types/helpers.mjs";
-
 //#region src/configure/services/workflow/wait-point.d.ts
 /**
  * A single wait point instance with typed `.wait()` and `.resolve()` methods.

package/dist/configure/services/workflow/workflow.d.mts

@@ -1,7 +1,7 @@
 import { MachineUserName } from "../auth/types.mjs";
 import { ConcurrencyPolicy, RetryPolicy } from "../../../types/workflow.generated.mjs";
+import "../../types/machine-user.mjs";
 import { WorkflowJob } from "./job.mjs";
-
 //#region src/configure/services/workflow/workflow.d.ts
 interface WorkflowConfig<Job extends WorkflowJob<any, any, any> = WorkflowJob<any, any, any>> {
   name: string;

package/dist/configure/types/field-runtime.d.mts

@@ -1,6 +1,5 @@
 import { TailorPrincipal } from "../../runtime/types.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/configure/types/field-runtime.d.ts
 type FieldParseArgs = {
   value: unknown;

package/dist/configure/types/field.d.mts

@@ -1,8 +1,7 @@
 import { EnumValue } from "./field.types.mjs";
-
 //#region src/configure/types/field.d.ts
 type AllowedValues = readonly [string | EnumValue, ...(string | EnumValue)[]];
-type AllowedValuesOutput<V extends AllowedValues> = V[number] extends infer T ? T extends string ? T : T extends {
+type AllowedValuesOutput<V extends AllowedValues> = V[number] extends (infer T) ? T extends string ? T : T extends {
   value: infer K;
 } ? K : never : never;
 //#endregion

package/dist/configure/types/field.types.d.mts

@@ -1,7 +1,3 @@
-import { TailorPrincipal } from "../../runtime/types.mjs";
-import { InferFieldsOutput, output } from "../../types/helpers.mjs";
-import { NonEmptyObject } from "type-fest";
-
 //#region src/configure/types/field.types.d.ts
 interface EnumValue {
   value: string;
@@ -47,50 +43,15 @@ type ArrayFieldOutput<T, O extends FieldOptions> = [O] extends [{
   array: true;
 }] ? T[] : T;
 /**
- * Validation function type
+ * Field validation function. Return an error message string to fail, or void/undefined to pass.
  */
-type ValidateFn<O, D = unknown> = (args: {
+type ValidateFn<O> = (args: {
   value: O;
-  data: D;
-  invoker: TailorPrincipal | null;
-}) => boolean;
+}) => string | void;
 /**
- * Validation configuration with custom error message
+ * Input type for field validation
  */
-type ValidateConfig<O, D = unknown> = [ValidateFn<O, D>, string];
-/**
- * Field-level validation function
- */
-type FieldValidateFn<O> = ValidateFn<O>;
-/**
- * Field-level validation configuration
- */
-type FieldValidateConfig<O> = ValidateConfig<O>;
-/**
- * Input type for field validation - can be either a function or a tuple of [function, errorMessage]
- */
-type FieldValidateInput<O> = FieldValidateFn<O> | FieldValidateConfig<O>;
-/**
- * Base validators type for field collections
- * @template F - Record of fields
- * @template ExcludeKeys - Keys to exclude from validation (default: "id" for TailorDB)
- */
-type ValidatorsBase<F extends Record<string, {
-  _defined: any;
-  _output: any;
-  [key: string]: any;
-}>, ExcludeKeys extends string = "id"> = NonEmptyObject<{ [K in Exclude<keyof F, ExcludeKeys> as F[K]["_defined"] extends {
-  validate: unknown;
-} ? never : K]?: ValidateFn<output<F[K]>, InferFieldsOutput<F>> | ValidateConfig<output<F[K]>, InferFieldsOutput<F>> | (ValidateFn<output<F[K]>, InferFieldsOutput<F>> | ValidateConfig<output<F[K]>, InferFieldsOutput<F>>)[] }>;
-/**
- * Validators type (by default excludes "id" field for TailorDB compatibility)
- * Can be used with both TailorField and TailorDBField
- */
-type Validators<F extends Record<string, {
-  _defined: any;
-  _output: any;
-  [key: string]: any;
-}>> = ValidatorsBase<F, "id">;
+type FieldValidateInput<O> = ValidateFn<O>;
 /**
  * Minimal structural interface for TailorField.
  * Defines only the properties needed by parser, plugin, cli, and types layers.
@@ -106,4 +67,4 @@ interface TailorField<Defined extends DefinedFieldMetadata = DefinedFieldMetadat
 }
 type TailorAnyField = TailorField<any>;
 //#endregion
-export { ArrayFieldOutput, DefinedFieldMetadata, EnumValue, FieldMetadata, FieldOptions, FieldOutput, FieldValidateInput, TailorAnyField, TailorField, TailorFieldType, TailorToTs, ValidateConfig, ValidateFn, Validators };
+export { ArrayFieldOutput, DefinedFieldMetadata, EnumValue, FieldMetadata, FieldOptions, FieldOutput, FieldValidateInput, TailorAnyField, TailorField, TailorFieldType, TailorToTs, ValidateFn };

package/dist/configure/types/index.d.mts

@@ -1,4 +1,5 @@
 import { MachineUserName, MachineUserNameRegistry } from "../services/auth/types.mjs";
 import { AllowedValues, AllowedValuesOutput } from "./field.mjs";
 import { TailorAnyField, TailorField } from "./type.mjs";
+import "./machine-user.mjs";
 export { AllowedValues, AllowedValuesOutput, type MachineUserName, type MachineUserNameRegistry, TailorAnyField, TailorField };

package/dist/configure/types/type.d.mts

@@ -1,8 +1,7 @@
-import { TypeLevelError } from "../../types/helpers.mjs";
 import { DefinedFieldMetadata, FieldMetadata, FieldValidateInput, TailorField as TailorField$1, TailorFieldType } from "./field.types.mjs";
+import { TypeLevelError } from "../../types/helpers.mjs";
 import { FieldParseArgs, FieldParseInternalArgs } from "./field-runtime.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/configure/types/type.d.ts
 type AnyBuilderMethod = any;
 type TailorAnyField = Omit<TailorField$1<AnyBuilderMethod, AnyBuilderMethod, FieldMetadata, TailorFieldType>, "fields"> & {

package/dist/kysely/index.d.mts

@@ -1,12 +1,11 @@
 import { ColumnType, ColumnType as ColumnType$1, Insertable, Insertable as Insertable$1, Kysely, Kysely as Kysely$1, KyselyConfig, KyselyConfig as KyselyConfig$1, Selectable, Selectable as Selectable$1, Transaction, Transaction as Transaction$1, Updateable, Updateable as Updateable$1, sql } from "kysely";
 import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
-
 //#region src/kysely/index.d.ts
 type Timestamp = ColumnType$1<Date, Date | string, Date | string>;
 type ResolveSelect<T> = T extends ColumnType$1<infer S, unknown, unknown> ? S : T;
 type ResolveInsert<T> = T extends ColumnType$1<unknown, infer I, unknown> ? I : T;
 type ResolveUpdate<T> = T extends ColumnType$1<unknown, unknown, infer U> ? U : T;
-type ObjectColumnType<T> = ColumnType$1<{ [K in keyof T]-?: Exclude<ResolveSelect<T[K]>, undefined> }, { [K in keyof T]: ResolveInsert<T[K]> }, { [K in keyof T]: ResolveUpdate<T[K]> }>;
+type ObjectColumnType<T> = ColumnType$1<{ [K in keyof T]-?: Exclude<ResolveSelect<T[K]>, undefined>; }, { [K in keyof T]: ResolveInsert<T[K]>; }, { [K in keyof T]: ResolveUpdate<T[K]>; }>;
 type ArrayColumnType<T> = ColumnType$1<ResolveSelect<T>[], ResolveInsert<T>[], ResolveUpdate<T>[]>;
 type Generated<T> = T extends ColumnType$1<infer S, infer I, infer U> ? ColumnType$1<S, I | undefined, U> : ColumnType$1<T, T | undefined, T>;
 type Serial<T = string | number> = ColumnType$1<T, never, never>;
@@ -18,8 +17,8 @@ type NamespaceDB<NS, N extends keyof NS = keyof NS> = TailordbKysely<NS[N]>;
  */
 declare function createGetDB<NS>(): <const N extends keyof NS & string>(namespace: N, config?: Omit<KyselyConfig$1, "dialect">) => TailordbKysely<NS[N]>;
 type NamespaceTransaction<NS, K extends keyof NS | TailordbKysely<NS[keyof NS]> = keyof NS> = K extends TailordbKysely<infer DB> ? Transaction$1<DB> : K extends keyof NS ? Transaction$1<NS[K]> : never;
-type NamespaceTableName<NS> = { [N in keyof NS]: keyof NS[N] }[keyof NS];
-type NamespaceTable<NS, T extends NamespaceTableName<NS>> = { [N in keyof NS]: T extends keyof NS[N] ? NS[N][T] : never }[keyof NS];
+type NamespaceTableName<NS> = { [N in keyof NS]: keyof NS[N]; }[keyof NS];
+type NamespaceTable<NS, T extends NamespaceTableName<NS>> = { [N in keyof NS]: T extends keyof NS[N] ? NS[N][T] : never; }[keyof NS];
 type NamespaceInsertable<NS, T extends NamespaceTableName<NS>> = Insertable$1<NamespaceTable<NS, T>>;
 type NamespaceSelectable<NS, T extends NamespaceTableName<NS>> = Selectable$1<NamespaceTable<NS, T>>;
 type NamespaceUpdateable<NS, T extends NamespaceTableName<NS>> = Updateable$1<NamespaceTable<NS, T>>;

package/dist/{kysely-type-D-zflMGf.mjs → kysely-type-DqIRgDYR.mjs}

@@ -44,7 +44,8 @@ function getNestedType(fieldConfig) {
 	const fieldTypes = fieldResults.map((r) => r.fieldType);
 	const obj = `{\n  ${fieldTypes.join(";\n  ")}${fieldTypes.length > 0 ? ";" : ""}\n}`;
 	const hasOptionalFields = Object.values(fields).some((config) => config.required !== true);
-	if (aggregatedUtilityTypes.Timestamp || hasOptionalFields) return {
+	const hasGeneratedFields = Object.values(fields).some((config) => config.hooks?.create || config.default !== void 0);
+	if (aggregatedUtilityTypes.Timestamp || hasOptionalFields || hasGeneratedFields) return {
 		type: `ObjectColumnType<${obj}>`,
 		usedUtilityTypes: aggregatedUtilityTypes
 	};
@@ -116,7 +117,7 @@ function generateFieldType(fieldConfig) {
 		usedUtilityTypes.Serial = true;
 		finalType = `Serial<${finalType}>`;
 	}
-	if (fieldConfig.hooks?.create) finalType = `Generated<${finalType}>`;
+	if (fieldConfig.hooks?.create || fieldConfig.default !== void 0) finalType = `Generated<${finalType}>`;
 	return {
 		type: finalType,
 		usedUtilityTypes
@@ -271,4 +272,4 @@ function kyselyTypePlugin(options) {
 
 //#endregion
 export { kyselyTypePlugin as n, KyselyGeneratorID as t };
-//# sourceMappingURL=kysely-type-D-zflMGf.mjs.map
+//# sourceMappingURL=kysely-type-DqIRgDYR.mjs.map