Config types

interface DrizzleCrudConfig {
  /** Required. */
  dialect: 'postgresql' | 'mysql';

  /** PostgreSQL: connection string. The module builds the connection. */
  connectionString?: string;

  /** Any dialect: pre-built Drizzle instance. Required for MySQL. */
  db?: any;

  /** Required when building from connectionString. */
  schema?: Record<string, unknown>;

  /** Per-project defaults applied to every entity unless overridden. */
  defaults?: {
    softDelete?: boolean;
    timestamps?: boolean;
    /** Either key alone keeps the other's default. */
    pagination?: { defaultLimit?: number; maxLimit?: number };
    sortOrder?: 'asc' | 'desc';
  };

  /** Dialect tuning. */
  sql?: {
    caseSensitive?: boolean;
    useReturning?: boolean;
    /** @deprecated Has no effect. */
    jsonSupport?: boolean;
    /** @deprecated Has no effect. */
    enableFullTextSearch?: boolean;
  };

  /** Module-level write events. See /docs/events. */
  hooks?: {
    enableGlobalHooks?: boolean;   // default false
    subscribers?: Array<Record<string, unknown>>; // CrudSubscriber[]
  };
}

interface SqlCrudConfig {
  // ---- Set by the module ----
  dialect: 'postgresql' | 'mysql';
  db: any;
  table: any;

  // ---- Primary key ----
  primaryKey: string;              // default 'id'
  /** @deprecated Has no effect: the type comes from the column. */
  primaryKeyType?:
    | 'serial' | 'bigserial' | 'int' | 'bigint' | 'uuid';

  // ---- Soft delete ----
  softDelete?: {
    enabled: boolean;
    column: string;               // the table key, e.g. 'deleted_at' or 'deletedAt'
  };

  // ---- Timestamps ----
  timestamps?: {
    createdAt: string;            // the table key, e.g. 'created_at'
    updatedAt: string;            // the table key, e.g. 'updated_at'
  };

  // ---- Pagination ----
  pagination?: {
    defaultLimit: number;
    maxLimit: number;
  };

  // ---- Default ORDER BY ----
  defaultSort?: Array<{
    column: string;
    order: 'asc' | 'desc';
  }>;

  // ---- Dialect tuning ----
  sql?: {
    caseSensitive: boolean;
    useReturning: boolean;
    /** @deprecated Has no effect. */
    jsonSupport: boolean;
    /** @deprecated Has no effect. */
    enableFullTextSearch: boolean;
  };

  // ---- Relations: belongs-to, has-many, many-to-many, nested ----
  relations?: Record<string, RelationConfig>;

  // ---- Allowlists (CrudAllowlists). Unset allows everything. ----
  filterableColumns?: string[];   // columns and 'relation.column'
  sortableColumns?: string[];     // columns and 'belongsTo.column'
  selectableColumns?: string[];   // columns and dotted paths
  searchableColumns?: string[];
  loadableRelations?: string[];   // relation paths, also for counts
  writableColumns?: string[];     // create, update, upsert
  writableRelations?: string[];   // nested create, attach, detach, sync

  // ---- Tenant scope: ANDed into every read and write, set on create ----
  scope?:
    | Record<string, unknown>
    | ((ctx: Record<string, unknown>) => Record<string, unknown> | null);

  // ---- Optimistic locking: integer column, +1 on every write ----
  versionColumn?: string;

  // ---- Event bus, set by the module when hooks.enableGlobalHooks is on ----
  events?: { emit(event: unknown): Promise<void> }; // a CrudEventBus
}

type RelationType = 'belongsTo' | 'hasMany' | 'manyToMany';

interface RelationConfig {
  table: any;                  // the target Drizzle table
  type?: RelationType;         // defaults to 'belongsTo'
  // belongs-to
  localKey?: string;           // the FK column on the *current* table (required)
  references?: string;         // the target column (defaults to 'id')
  // has-many
  foreignKey?: string;         // the column on the *target* table pointing back here (required)
  parentKey?: string;          // the column on the current table it matches (defaults to that table's primary key)
  // many-to-many
  through?: any;               // the join table (required)
  throughLocalKey?: string;    // join column matching parentKey (required)
  throughForeignKey?: string;  // join column matching references (required)
  // collections only
  orderBy?: SortColumn[];      // how to order the children, applied in SQL
  // relations of the RELATED table, addressable as 'relName.childName'
  relations?: Record<string, RelationConfig>;
}

type RelationsConfig = Record<string, RelationConfig>;

interface RelationNode {
  name: string;
  config: RelationConfig;
  children: RelationNode[];
  joined?: boolean;   // folded into the main query as a LEFT JOIN
}

interface SelectTree {
  base: string[];
  relations: Record<string, SelectTree>;
}

type SqlSearchMode = 'ilike' | 'fullText';

interface SqlSearchOptions {
  term: string;
  columns: string[];
  mode?: SqlSearchMode;
}

type CrudFeatureConfig = Partial<
  Omit<SqlCrudConfig, 'softDelete' | 'timestamps' | 'pagination' | 'sql'>
> & {
  softDelete?: Partial<NonNullable<SqlCrudConfig['softDelete']>>;
  timestamps?: Partial<NonNullable<SqlCrudConfig['timestamps']>>;
  pagination?: Partial<NonNullable<SqlCrudConfig['pagination']>>;
  sql?: Partial<NonNullable<SqlCrudConfig['sql']>>;
};

interface CrudFeature {
  service: typeof SqlBaseCrudService;
  table: any;                  // Drizzle table
  config?: CrudFeatureConfig;  // per-entity overrides
}

type SqlDialect = 'postgresql' | 'mysql';
type PrimaryKeyType = 'serial' | 'bigserial' | 'int' | 'bigint' | 'uuid';
type SortOrder = 'asc' | 'desc';
interface SortColumn { column: string; order: SortOrder }