@tailor-platform/sdk 2.0.0-next.3 → 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;
@@ -366,19 +413,19 @@ declare function object<const F extends Record<string, TailorAnyDBField> & Exclu
 }, FieldOutput<InferFieldsOutput<F>, Opt>>;
 declare const idField: TailorDBFieldInstance<"uuid", FieldOptions, string>;
 type idField = typeof idField;
-type DBType<F extends {
+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 type with the specified fields.
- * An `id` field (UUID) is automatically added to every type.
- * @param name - The name of the type, or a tuple of [name, pluralForm]
- * @param fields - The field definitions for the type
- * @returns A new TailorDBType instance
+ * Creates a new database table with the specified fields.
+ * An `id` field (UUID) is automatically added to every table.
+ * @param name - The name of the table, or a tuple of [name, pluralForm]
+ * @param fields - The field definitions for the table
+ * @returns A new TailorDB table instance
  * @example
- * export const user = db.type("User", {
+ * export const user = db.table("User", {
  *   name: db.string(),
  *   email: db.string(),
  *   age: db.int({ optional: true }),
@@ -388,23 +435,23 @@ type DBType<F extends {
  * // Always export both the value and type:
  * export type user = typeof user;
  */
-declare function dbType<const F extends {
+declare function dbTable<const F extends {
   id?: never;
-} & Record<string, TailorAnyDBField>>(name: string | [string, string], fields: F): DBType<F>;
+} & Record<string, TailorAnyDBField>>(name: string | [string, string], fields: F): DBTable<F>;
 /**
- * Creates a new database type with the specified fields and description.
- * An `id` field (UUID) is automatically added to every type.
- * @param name - The name of the type, or a tuple of [name, pluralForm]
- * @param description - A description of the type
- * @param fields - The field definitions for the type
- * @returns A new TailorDBType instance
+ * Creates a new database table with the specified fields and description.
+ * An `id` field (UUID) is automatically added to every table.
+ * @param name - The name of the table, or a tuple of [name, pluralForm]
+ * @param description - A description of the table
+ * @param fields - The field definitions for the table
+ * @returns A new TailorDB table instance
  */
-declare function dbType<const F extends {
+declare function dbTable<const F extends {
   id?: never;
-} & Record<string, TailorAnyDBField>>(name: string | [string, string], description: string, fields: F): DBType<F>;
-/** TailorDB schema builder utilities for defining types and fields. */
+} & 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: {
-  type: typeof dbType;
+  table: typeof dbTable;
   uuid: typeof uuid;
   string: typeof string;
   bool: typeof bool;
@@ -418,36 +465,25 @@ 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.type("Model", {
+     * const model = db.table("Model", {
      *   name: db.string(),
      *   ...db.fields.timestamps(),
      * });
      */
     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

@@ -0,0 +1,70 @@
+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;
+} ? K : Fallback;
+type ResolveMatchType<Def> = Def extends {
+  matchType: infer M extends "exact" | "prefix";
+} ? M : "exact";
+/**
+ * Define a single workflow job function execution policy.
+ *
+ * Use this when declaring a policy outside the
+ * {@link defineWorkflowExecutionPolicies} builder — for example, when the
+ * runtime key prefix needs to differ from the corresponding workspace-unique
+ * name.
+ *
+ * When `matchType: "prefix"` is set, the returned instance has `keyFor(suffix)`
+ * instead of a directly-usable `key` (see {@link ExecutionPolicyWildcardInstance}).
+ * @param name - Workspace-unique name. Must match `^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$`.
+ * @param def - Optional overrides for `key` (defaults to `name`), `matchType`, `separator` (the `keyFor` join character, defaults to `.`), and concurrency
+ * @returns An execution policy instance
+ * @example
+ * export const perTenant = defineWorkflowExecutionPolicy("tenant-api", {
+ *   matchType: "prefix",
+ *   concurrencyPolicy: { maxConcurrentExecutions: 3 },
+ * });
+ *
+ * perTenant.keyFor(tenantId); // "tenant-api.<tenantId>"
+ */
+declare function defineWorkflowExecutionPolicy<const N extends string, const D extends (Omit<ExecutionPolicyDefInput, "name"> & {
+  separator?: string;
+}) | undefined = undefined>(name: N, def?: D): ResolvedExecutionPolicyInstance<ResolveKey<D, N>, ResolveMatchType<D>>;
+/**
+ * Define a group of workflow job function execution policies. Property names
+ * become the workspace-unique `name` and default `key` verbatim, matching the
+ * mental model of {@link defineWaitPoints}. Provide `name` / `key` explicitly
+ * to override the property-name default (for example, when the property name
+ * is not valid for the execution policy grammar or when the runtime key
+ * prefix needs to differ).
+ *
+ * When `matchType: "prefix"` is set, the returned instance has `keyFor(suffix)`
+ * instead of a directly-usable `key` (see {@link ExecutionPolicyWildcardInstance}).
+ * `matchType` can be combined with an explicit `key`, or left to apply to
+ * the property-name-derived prefix.
+ *
+ * The return type mirrors the builder's return type so JSDoc on each property
+ * is preserved in IDE autocompletion.
+ * @param builder - Callback that receives a `define` factory and returns a record of policies
+ * @param options - Group-wide options; `separator` overrides the `.` `keyFor` uses to join the prefix and suffix for every prefix policy in the group
+ * @returns The same object returned by the builder (with `name` / `key` resolved on each instance)
+ * @example
+ * export const executionPolicies = defineWorkflowExecutionPolicies((define) => ({
+ *   premium: define({ concurrencyPolicy: { maxConcurrentExecutions: 5 } }),
+ *   "tenant-api": define({
+ *     matchType: "prefix",
+ *     concurrencyPolicy: { maxConcurrentExecutions: 3 },
+ *   }),
+ * }));
+ *
+ * // In a workflow job function:
+ * await tailor.workflow.triggerJobFunction("worker", args, {
+ *   executionPolicyKey: executionPolicies.premium.key,
+ * });
+ * await tailor.workflow.triggerJobFunction("worker", args, {
+ *   executionPolicyKey: executionPolicies["tenant-api"].keyFor(input.tenantId),
+ * });
+ */
+declare function defineWorkflowExecutionPolicies<T extends Record<string, ExecutionPolicyInstance>>(builder: (define: <const D extends ExecutionPolicyDefInput | undefined = undefined>(def?: D) => ResolvedExecutionPolicyInstance<ResolveKey<D, string>, ResolveMatchType<D>>) => T, options?: ExecutionPolicyGroupOptions): T;
+//#endregion
+export { type ExecutionPolicyConcurrency, type ExecutionPolicyDefInput, type ExecutionPolicyExactInstance, type ExecutionPolicyGroupOptions, type ExecutionPolicyInstance, type ExecutionPolicyWildcardInstance, type ResolvedExecutionPolicyInstance, defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy };

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

@@ -0,0 +1,103 @@
+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
+ * resolve to a policy's `executionPolicyKey`.
+ */
+interface ExecutionPolicyConcurrency {
+  /** Maximum number of concurrent executions allowed per resolved key. */
+  maxConcurrentExecutions: number;
+}
+/** Fields shared by both {@link ExecutionPolicyExactInstance} and {@link ExecutionPolicyWildcardInstance}. */
+interface ExecutionPolicyBase {
+  /** Workspace-unique name for this policy. */
+  readonly name: string;
+  /** Optional per-key concurrency cap. */
+  readonly concurrencyPolicy?: ExecutionPolicyConcurrency;
+}
+/**
+ * An execution policy declared with `matchType: "exact"` (the default).
+ * `key` is branded as {@link ExecutionPolicyKey}, so it can be passed
+ * directly as the `executionPolicyKey` option.
+ */
+interface ExecutionPolicyExactInstance<Key extends string = string> extends ExecutionPolicyBase {
+  /** Declared key; the platform registers it verbatim. */
+  readonly key: Key & ExecutionPolicyKey;
+  readonly matchType: "exact";
+}
+/**
+ * An execution policy declared with `matchType: "prefix"`. The platform
+ * registers the declared key prefix with a trailing `*`, and matches every
+ * dispatch whose runtime key begins with that prefix. There is no
+ * directly-usable `key` — use `keyFor` to build a concrete, branded runtime
+ * key at the call site instead of hand-concatenating the prefix and a
+ * suffix.
+ */
+interface ExecutionPolicyWildcardInstance extends ExecutionPolicyBase {
+  readonly matchType: "prefix";
+  /**
+   * Build a concrete runtime key by appending `suffix` after this policy's
+   * declared key prefix, separated by `.` unless a different separator was
+   * configured where this policy was declared.
+   * @param suffix - Value appended after the wildcard prefix
+   * @returns The concrete key to pass as `executionPolicyKey`
+   * @throws If the resulting key does not match the execution policy key
+   * grammar (for example, an empty `suffix`)
+   * @example
+   * // key: "tenant-api", matchType: "prefix"
+   * tenantApi.keyFor(tenantId); // "tenant-api.<tenantId>"
+   */
+  keyFor(suffix: string): ExecutionPolicyKey;
+}
+/**
+ * A declared workflow job function execution policy — either
+ * {@link ExecutionPolicyExactInstance} or {@link ExecutionPolicyWildcardInstance}.
+ */
+type ExecutionPolicyInstance<Key extends string = string> = ExecutionPolicyExactInstance<Key> | ExecutionPolicyWildcardInstance;
+/**
+ * Resolves to {@link ExecutionPolicyWildcardInstance} when `MatchType` is
+ * known at the type level to be `"prefix"`, to {@link ExecutionPolicyExactInstance}
+ * when it's known to be `"exact"`, or to their union when `MatchType` is the
+ * unnarrowed `"exact" | "prefix"` (e.g. a caller passed a non-literal
+ * `matchType`) — narrowing to one branch in that case would claim a `key` or
+ * `keyFor` that may not exist on the actual runtime instance.
+ */
+type ResolvedExecutionPolicyInstance<Key extends string, MatchType extends "exact" | "prefix"> = "exact" | "prefix" extends MatchType ? ExecutionPolicyExactInstance<Key> | ExecutionPolicyWildcardInstance : MatchType extends "prefix" ? ExecutionPolicyWildcardInstance : ExecutionPolicyExactInstance<Key>;
+/**
+ * Body of an execution policy declaration.
+ *
+ * When both `name` and `key` are omitted in the `defineWorkflowExecutionPolicies`
+ * builder, the property name is used verbatim for both (like
+ * `defineWaitPoints`). Provide `name` when the property identifier is not
+ * valid execution policy grammar, and provide `key` when the runtime key
+ * prefix needs to differ from `name` (e.g. it needs `:` or `.`).
+ */
+interface ExecutionPolicyDefInput {
+  /** Overrides the property-name-derived `name`. 3-63 characters from `[a-z0-9-]`; must start and end with `[a-z0-9]`. */
+  name?: string;
+  /** Overrides the property-name-derived `key` prefix. Independent of `matchType` — both may be set together. */
+  key?: string;
+  /**
+   * `"exact"` (the default) matches a dispatch whose runtime key equals
+   * `key` (or the resolved `name`, if `key` is omitted). `"prefix"`
+   * registers `key` as a wildcard prefix — the platform appends a trailing
+   * `*`, and the resulting instance exposes `keyFor(suffix)` to build
+   * concrete dispatch keys instead of a directly-usable `key`.
+   */
+  matchType?: "exact" | "prefix";
+  /** Optional per-key concurrency cap. */
+  concurrencyPolicy?: ExecutionPolicyConcurrency;
+}
+/**
+ * Options for {@link defineWorkflowExecutionPolicies}, applying to every
+ * policy declared by the builder (not settable per policy).
+ */
+interface ExecutionPolicyGroupOptions {
+  /**
+   * Separator `keyFor(suffix)` inserts between a wildcard policy's declared
+   * `key` prefix and `suffix`. Defaults to `.`.
+   */
+  separator?: string;
+}
+//#endregion
+export { ExecutionPolicyConcurrency, ExecutionPolicyDefInput, ExecutionPolicyExactInstance, ExecutionPolicyGroupOptions, ExecutionPolicyInstance, ExecutionPolicyWildcardInstance, ResolvedExecutionPolicyInstance };

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

@@ -1,6 +1,9 @@
+import { ExecutionPolicyConcurrency, ExecutionPolicyDefInput, ExecutionPolicyExactInstance, ExecutionPolicyGroupOptions, ExecutionPolicyInstance, ExecutionPolicyWildcardInstance, ResolvedExecutionPolicyInstance } from "./execution-policy.types.mjs";
 import { WorkflowServiceConfig, WorkflowServiceInput } from "../../config/types.mjs";
 import { ConcurrencyPolicy, RetryPolicy } from "../../../types/workflow.generated.mjs";
 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";
-export { type ConcurrencyPolicy, type RetryPolicy, WaitPointInstance, Workflow, WorkflowConfig, WorkflowJob, WorkflowJobContext, type WorkflowServiceConfig, type WorkflowServiceInput, createWaitPoint, createWaitPoints, createWorkflow, createWorkflowJob };
+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 };