metal-orm 1.0.14 → 1.0.15

package/src/schema/column.ts

@@ -1,252 +1,252 @@
 /**
  * Supported column data types for database schema definitions
  */
-export type ColumnType =
-  | 'INT'
-  | 'INTEGER'
-  | 'BIGINT'
-  | 'VARCHAR'
-  | 'TEXT'
-  | 'JSON'
-  | 'ENUM'
-  | 'DECIMAL'
-  | 'FLOAT'
-  | 'DOUBLE'
-  | 'UUID'
-  | 'DATE'
-  | 'DATETIME'
-  | 'TIMESTAMP'
-  | 'TIMESTAMPTZ'
-  | 'BOOLEAN'
-  | 'int'
-  | 'integer'
-  | 'bigint'
-  | 'varchar'
-  | 'text'
-  | 'json'
-  | 'enum'
-  | 'decimal'
-  | 'float'
-  | 'double'
-  | 'uuid'
-  | 'date'
-  | 'datetime'
-  | 'timestamp'
-  | 'timestamptz'
-  | 'boolean';
-
-export type ReferentialAction =
-  | 'NO ACTION'
-  | 'RESTRICT'
-  | 'CASCADE'
-  | 'SET NULL'
-  | 'SET DEFAULT';
-
-export interface RawDefaultValue {
-  raw: string;
-}
-
-export type DefaultValue = unknown | RawDefaultValue;
-
-export interface ForeignKeyReference {
-  /** Target table name */
-  table: string;
-  /** Target column name */
-  column: string;
-  /** Optional constraint name */
-  name?: string;
-  /** ON DELETE action */
-  onDelete?: ReferentialAction;
-  /** ON UPDATE action */
-  onUpdate?: ReferentialAction;
-  /** Whether the constraint is deferrable (Postgres) */
-  deferrable?: boolean;
-}
-
-/**
- * Definition of a database column
- */
-export interface ColumnDef<T extends ColumnType = ColumnType> {
-  /** Column name (filled at runtime by defineTable) */
-  name: string;
-  /** Data type of the column */
-  type: T;
-  /** Whether this column is a primary key */
-  primary?: boolean;
-  /** Whether this column cannot be null */
-  notNull?: boolean;
-  /** Whether this column must be unique (or name of the unique constraint) */
-  unique?: boolean | string;
-  /** Default value for the column */
-  default?: DefaultValue;
-  /** Whether the column auto-increments / identity */
-  autoIncrement?: boolean;
-  /** Identity strategy where supported */
-  generated?: 'always' | 'byDefault';
-  /** Inline check constraint expression */
-  check?: string;
-  /** Foreign key reference */
-  references?: ForeignKeyReference;
-  /** Column comment/description */
-  comment?: string;
-  /** Additional arguments for the column type (e.g., VARCHAR length) */
-  args?: any[];
-  /** Table name this column belongs to (filled at runtime by defineTable) */
-  table?: string;
-}
-
+export type ColumnType =
+  | 'INT'
+  | 'INTEGER'
+  | 'BIGINT'
+  | 'VARCHAR'
+  | 'TEXT'
+  | 'JSON'
+  | 'ENUM'
+  | 'DECIMAL'
+  | 'FLOAT'
+  | 'DOUBLE'
+  | 'UUID'
+  | 'DATE'
+  | 'DATETIME'
+  | 'TIMESTAMP'
+  | 'TIMESTAMPTZ'
+  | 'BOOLEAN'
+  | 'int'
+  | 'integer'
+  | 'bigint'
+  | 'varchar'
+  | 'text'
+  | 'json'
+  | 'enum'
+  | 'decimal'
+  | 'float'
+  | 'double'
+  | 'uuid'
+  | 'date'
+  | 'datetime'
+  | 'timestamp'
+  | 'timestamptz'
+  | 'boolean';
+
+export type ReferentialAction =
+  | 'NO ACTION'
+  | 'RESTRICT'
+  | 'CASCADE'
+  | 'SET NULL'
+  | 'SET DEFAULT';
+
+export interface RawDefaultValue {
+  raw: string;
+}
+
+export type DefaultValue = unknown | RawDefaultValue;
+
+export interface ForeignKeyReference {
+  /** Target table name */
+  table: string;
+  /** Target column name */
+  column: string;
+  /** Optional constraint name */
+  name?: string;
+  /** ON DELETE action */
+  onDelete?: ReferentialAction;
+  /** ON UPDATE action */
+  onUpdate?: ReferentialAction;
+  /** Whether the constraint is deferrable (Postgres) */
+  deferrable?: boolean;
+}
+
+/**
+ * Definition of a database column
+ */
+export interface ColumnDef<T extends ColumnType = ColumnType> {
+  /** Column name (filled at runtime by defineTable) */
+  name: string;
+  /** Data type of the column */
+  type: T;
+  /** Whether this column is a primary key */
+  primary?: boolean;
+  /** Whether this column cannot be null */
+  notNull?: boolean;
+  /** Whether this column must be unique (or name of the unique constraint) */
+  unique?: boolean | string;
+  /** Default value for the column */
+  default?: DefaultValue;
+  /** Whether the column auto-increments / identity */
+  autoIncrement?: boolean;
+  /** Identity strategy where supported */
+  generated?: 'always' | 'byDefault';
+  /** Inline check constraint expression */
+  check?: string;
+  /** Foreign key reference */
+  references?: ForeignKeyReference;
+  /** Column comment/description */
+  comment?: string;
+  /** Additional arguments for the column type (e.g., VARCHAR length) */
+  args?: any[];
+  /** Table name this column belongs to (filled at runtime by defineTable) */
+  table?: string;
+}
+
 /**
  * Factory for creating column definitions with common data types
  */
-export const col = {
-  /**
-   * Creates an integer column definition
-   * @returns ColumnDef with INT type
-   */
-  int: (): ColumnDef<'INT'> => ({ name: '', type: 'INT' }),
-
-  /**
-   * Creates a big integer column definition
-   */
-  bigint: (): ColumnDef<'BIGINT'> => ({ name: '', type: 'BIGINT' }),
-
-  /**
-   * Creates a variable character column definition
-   * @param length - Maximum length of the string
-   * @returns ColumnDef with VARCHAR type
-   */
-  varchar: (length: number): ColumnDef<'VARCHAR'> => ({ name: '', type: 'VARCHAR', args: [length] }),
-
-  /**
-   * Creates a fixed precision decimal column definition
-   */
-  decimal: (precision: number, scale = 0): ColumnDef<'DECIMAL'> => ({
-    name: '',
-    type: 'DECIMAL',
-    args: [precision, scale]
-  }),
-
-  /**
-   * Creates a floating point column definition
-   */
-  float: (precision?: number): ColumnDef<'FLOAT'> => ({
-    name: '',
-    type: 'FLOAT',
-    args: precision !== undefined ? [precision] : undefined
-  }),
-
-  /**
-   * Creates a UUID column definition
-   */
-  uuid: (): ColumnDef<'UUID'> => ({ name: '', type: 'UUID' }),
-
-  /**
-   * Creates a timestamp column definition
-   */
-  timestamp: (): ColumnDef<'TIMESTAMP'> => ({ name: '', type: 'TIMESTAMP' }),
-
-  /**
-   * Creates a timestamptz column definition
-   */
-  timestamptz: (): ColumnDef<'TIMESTAMPTZ'> => ({ name: '', type: 'TIMESTAMPTZ' }),
-
-  /**
-   * Creates a date column definition
-   */
-  date: (): ColumnDef<'DATE'> => ({ name: '', type: 'DATE' }),
-
-  /**
-   * Creates a datetime column definition
-   */
-  datetime: (): ColumnDef<'DATETIME'> => ({ name: '', type: 'DATETIME' }),
-
-  /**
-   * Creates a JSON column definition
-   * @returns ColumnDef with JSON type
-   */
-  json: (): ColumnDef<'JSON'> => ({ name: '', type: 'JSON' }),
-
-  /**
-   * Creates a boolean column definition
-   * @returns ColumnDef with BOOLEAN type
-   */
-  boolean: (): ColumnDef<'BOOLEAN'> => ({ name: '', type: 'BOOLEAN' }),
-
-  /**
-   * Creates an enum column definition
-   * @param values - Enum values
-   */
-  enum: (values: string[]): ColumnDef<'ENUM'> => ({ name: '', type: 'ENUM', args: values }),
-
-  /**
-   * Marks a column definition as a primary key
-   * @param def - Column definition to modify
-   * @returns Modified ColumnDef with primary: true
-   */
-  primaryKey: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> =>
-    ({ ...def, primary: true }),
-
-  /**
-   * Marks a column as NOT NULL
-   */
-  notNull: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> =>
-    ({ ...def, notNull: true }),
-
-  /**
-   * Marks a column as UNIQUE
-   */
-  unique: <T extends ColumnType>(def: ColumnDef<T>, name?: string): ColumnDef<T> =>
-    ({
-      ...def,
-      unique: name ?? true
-    }),
-
-  /**
-   * Sets a default value for the column
-   */
-  default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown): ColumnDef<T> =>
-    ({
-      ...def,
-      default: value
-    }),
-
-  /**
-   * Sets a raw SQL default value for the column
-   */
-  defaultRaw: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
-    ({
-      ...def,
-      default: { raw: expression }
-    }),
-
-  /**
-   * Marks a column as auto-increment / identity
-   */
-  autoIncrement: <T extends ColumnType>(
-    def: ColumnDef<T>,
-    strategy: ColumnDef['generated'] = 'byDefault'
-  ): ColumnDef<T> =>
-    ({
-      ...def,
-      autoIncrement: true,
-      generated: strategy
-    }),
-
-  /**
-   * Adds a foreign key reference
-   */
-  references: <T extends ColumnType>(def: ColumnDef<T>, ref: ForeignKeyReference): ColumnDef<T> =>
-    ({
-      ...def,
-      references: ref
-    }),
-
-  /**
-   * Adds a check constraint to the column
-   */
-  check: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
-    ({
-      ...def,
-      check: expression
-    })
-};
+export const col = {
+  /**
+   * Creates an integer column definition
+   * @returns ColumnDef with INT type
+   */
+  int: (): ColumnDef<'INT'> => ({ name: '', type: 'INT' }),
+
+  /**
+   * Creates a big integer column definition
+   */
+  bigint: (): ColumnDef<'BIGINT'> => ({ name: '', type: 'BIGINT' }),
+
+  /**
+   * Creates a variable character column definition
+   * @param length - Maximum length of the string
+   * @returns ColumnDef with VARCHAR type
+   */
+  varchar: (length: number): ColumnDef<'VARCHAR'> => ({ name: '', type: 'VARCHAR', args: [length] }),
+
+  /**
+   * Creates a fixed precision decimal column definition
+   */
+  decimal: (precision: number, scale = 0): ColumnDef<'DECIMAL'> => ({
+    name: '',
+    type: 'DECIMAL',
+    args: [precision, scale]
+  }),
+
+  /**
+   * Creates a floating point column definition
+   */
+  float: (precision?: number): ColumnDef<'FLOAT'> => ({
+    name: '',
+    type: 'FLOAT',
+    args: precision !== undefined ? [precision] : undefined
+  }),
+
+  /**
+   * Creates a UUID column definition
+   */
+  uuid: (): ColumnDef<'UUID'> => ({ name: '', type: 'UUID' }),
+
+  /**
+   * Creates a timestamp column definition
+   */
+  timestamp: (): ColumnDef<'TIMESTAMP'> => ({ name: '', type: 'TIMESTAMP' }),
+
+  /**
+   * Creates a timestamptz column definition
+   */
+  timestamptz: (): ColumnDef<'TIMESTAMPTZ'> => ({ name: '', type: 'TIMESTAMPTZ' }),
+
+  /**
+   * Creates a date column definition
+   */
+  date: (): ColumnDef<'DATE'> => ({ name: '', type: 'DATE' }),
+
+  /**
+   * Creates a datetime column definition
+   */
+  datetime: (): ColumnDef<'DATETIME'> => ({ name: '', type: 'DATETIME' }),
+
+  /**
+   * Creates a JSON column definition
+   * @returns ColumnDef with JSON type
+   */
+  json: (): ColumnDef<'JSON'> => ({ name: '', type: 'JSON' }),
+
+  /**
+   * Creates a boolean column definition
+   * @returns ColumnDef with BOOLEAN type
+   */
+  boolean: (): ColumnDef<'BOOLEAN'> => ({ name: '', type: 'BOOLEAN' }),
+
+  /**
+   * Creates an enum column definition
+   * @param values - Enum values
+   */
+  enum: (values: string[]): ColumnDef<'ENUM'> => ({ name: '', type: 'ENUM', args: values }),
+
+  /**
+   * Marks a column definition as a primary key
+   * @param def - Column definition to modify
+   * @returns Modified ColumnDef with primary: true
+   */
+  primaryKey: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> =>
+    ({ ...def, primary: true }),
+
+  /**
+   * Marks a column as NOT NULL
+   */
+  notNull: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> =>
+    ({ ...def, notNull: true }),
+
+  /**
+   * Marks a column as UNIQUE
+   */
+  unique: <T extends ColumnType>(def: ColumnDef<T>, name?: string): ColumnDef<T> =>
+    ({
+      ...def,
+      unique: name ?? true
+    }),
+
+  /**
+   * Sets a default value for the column
+   */
+  default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown): ColumnDef<T> =>
+    ({
+      ...def,
+      default: value
+    }),
+
+  /**
+   * Sets a raw SQL default value for the column
+   */
+  defaultRaw: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
+    ({
+      ...def,
+      default: { raw: expression }
+    }),
+
+  /**
+   * Marks a column as auto-increment / identity
+   */
+  autoIncrement: <T extends ColumnType>(
+    def: ColumnDef<T>,
+    strategy: ColumnDef['generated'] = 'byDefault'
+  ): ColumnDef<T> =>
+    ({
+      ...def,
+      autoIncrement: true,
+      generated: strategy
+    }),
+
+  /**
+   * Adds a foreign key reference
+   */
+  references: <T extends ColumnType>(def: ColumnDef<T>, ref: ForeignKeyReference): ColumnDef<T> =>
+    ({
+      ...def,
+      references: ref
+    }),
+
+  /**
+   * Adds a check constraint to the column
+   */
+  check: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
+    ({
+      ...def,
+      check: expression
+    })
+};

package/src/schema/relation.ts

@@ -1,9 +1,11 @@
-import { TableDef } from './table.js';
+import type { TableDef } from './table.js';
 
 /**
  * Types of relationships supported between tables
  */
 export const RelationKinds = {
+    /** One-to-one relationship */
+    HasOne: 'HAS_ONE',
     /** One-to-many relationship */
     HasMany: 'HAS_MANY',
     /** Many-to-one relationship */
@@ -30,6 +32,17 @@ export interface HasManyRelation<TTarget extends TableDef = TableDef> {
     cascade?: CascadeMode;
 }
 
+/**
+ * One-to-one relationship definition
+ */
+export interface HasOneRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.HasOne;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+
 /**
  * Many-to-one relationship definition
  */
@@ -62,6 +75,7 @@ export interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
  */
 export type RelationDef =
   | HasManyRelation
+  | HasOneRelation
   | BelongsToRelation
   | BelongsToManyRelation;
 
@@ -90,6 +104,26 @@ export const hasMany = <TTarget extends TableDef>(
     cascade
 });
 
+/**
+ * Creates a one-to-one relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns HasOneRelation definition
+ */
+export const hasOne = <TTarget extends TableDef>(
+  target: TTarget,
+  foreignKey: string,
+  localKey?: string,
+  cascade?: CascadeMode
+): HasOneRelation<TTarget> => ({
+    type: RelationKinds.HasOne,
+    target,
+    foreignKey,
+    localKey,
+    cascade
+});
+
 /**
  * Creates a many-to-one relationship definition
  * @param target - Target table of the relationship

package/src/schema/table.ts

@@ -1,5 +1,5 @@
-import { ColumnDef } from './column.js';
-import { RelationDef } from './relation.js';
+import type { ColumnDef } from './column.js';
+import type { RelationDef } from './relation.js';
 
 export interface IndexColumn {
   column: string;
@@ -35,14 +35,14 @@ export interface TableHooks {
   afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
   beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
   afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-  beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
-  afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
-}
-
-/**
- * Definition of a database table with its columns and relationships
- * @typeParam T - Type of the columns record
- */
+  beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
+  afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
+}
+
+/**
+ * Definition of a database table with its columns and relationships
+ * @typeParam T - Type of the columns record
+ */
 export interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
   /** Name of the table */
   name: string;
@@ -67,24 +67,24 @@ export interface TableDef<T extends Record<string, ColumnDef> = Record<string, C
   charset?: string;
   collation?: string;
 }
-
-/**
- * Creates a table definition with columns and relationships
- * @typeParam T - Type of the columns record
- * @param name - Name of the table
- * @param columns - Record of column definitions
- * @param relations - Record of relationship definitions (optional)
- * @returns Complete table definition with runtime-filled column metadata
- *
- * @example
- * ```typescript
- * const usersTable = defineTable('users', {
- *   id: col.primaryKey(col.int()),
- *   name: col.varchar(255),
- *   email: col.varchar(255)
- * });
- * ```
- */
+
+/**
+ * Creates a table definition with columns and relationships
+ * @typeParam T - Type of the columns record
+ * @param name - Name of the table
+ * @param columns - Record of column definitions
+ * @param relations - Record of relationship definitions (optional)
+ * @returns Complete table definition with runtime-filled column metadata
+ *
+ * @example
+ * ```typescript
+ * const usersTable = defineTable('users', {
+ *   id: col.primaryKey(col.int()),
+ *   name: col.varchar(255),
+ *   email: col.varchar(255)
+ * });
+ * ```
+ */
 export const defineTable = <T extends Record<string, ColumnDef>>(
     name: string,
     columns: T,