@bunyad/orm 0.1.0-alpha.0

package/dist/factory.d.ts

@@ -0,0 +1,68 @@
+import type { Model, ModelClass } from "./model.js";
+export type FactoryAttributes = Record<string, unknown>;
+export type FactoryState = FactoryAttributes | ((attributes: FactoryAttributes) => FactoryAttributes | Promise<FactoryAttributes>);
+export type FactorySequenceState = FactoryAttributes | ((sequence: number) => FactoryAttributes);
+/**
+ * Lightweight faker for factory definitions (`fake().email()`).
+ */
+export type FakeGenerator = {
+    uuid(): string;
+    word(): string;
+    words(count?: number): string;
+    sentence(): string;
+    name(): string;
+    firstName(): string;
+    lastName(): string;
+    email(): string;
+    number(max?: number): number;
+    boolean(): boolean;
+};
+/** Bun-friendly faker used inside factory `definition()`. */
+export declare function fake(): FakeGenerator;
+/**
+ * Model factory — `definition` / `make` / `create` / `count`, plus
+ * fluent `state`, `sequence`, relationship helpers, and lifecycle callbacks.
+ */
+/** Marks a factory after `count()`, so `create()` / `make()` type as `T[]`. */
+type ManyModels = {
+    readonly __many: true;
+};
+export declare abstract class Factory<T extends Model = Model> {
+    #private;
+    protected abstract model(): ModelClass;
+    /** Public model class accessor for relationship factories. */
+    modelClass(): ModelClass;
+    definition(): FactoryAttributes | Promise<FactoryAttributes>;
+    /** Number of models to make/create. */
+    count(amount: number): this & ManyModels;
+    /** Merge attribute overrides (object or callback) into every model. */
+    state(state: FactoryState): this;
+    /**
+     * Cycle attribute sets across models.
+     * Sequence callbacks receive a 1-based index.
+     */
+    sequence(...states: FactorySequenceState[]): this;
+    /** Run after an in-memory model is built (`make` / before persist). */
+    afterMaking(callback: (model: T) => void | Promise<void>): this;
+    /** Run after a model is persisted (`create`). */
+    afterCreating(callback: (model: T) => void | Promise<void>): this;
+    /**
+     * Create related models after the parent (`has(PostFactory.new().count(3))`).
+     */
+    has(factory: Factory, relationship?: string): this;
+    /**
+     * Associate a parent model / factory (`for(TeamFactory.new())`).
+     */
+    for(parent: Model | Factory, relationship?: string): this;
+    /**
+     * Attach related models on a belongs-to-many after create.
+     */
+    hasAttached(related: Factory | Model | Model[], pivot?: FactoryAttributes, relationship?: string): this;
+    /** `Factory::new()`. */
+    static new<T extends Factory>(this: new () => T): T;
+    /** Build an in-memory model instance (not persisted). */
+    make(attributes?: FactoryAttributes): Promise<this extends ManyModels ? T[] : T>;
+    /** Persist model(s) via `Model.forceCreate` (factories set guarded columns too). */
+    create(attributes?: FactoryAttributes): Promise<this extends ManyModels ? T[] : T>;
+}
+export {};

package/dist/factory.js

@@ -0,0 +1,265 @@
+const WORDS = [
+    "alpha",
+    "bravo",
+    "cedar",
+    "delta",
+    "ember",
+    "flint",
+    "grove",
+    "harbor",
+    "ivory",
+    "jade",
+    "kite",
+    "lunar",
+    "maple",
+    "nova",
+    "orbit",
+    "pine",
+    "quartz",
+    "river",
+    "sage",
+    "tide",
+];
+function pickWord() {
+    return WORDS[Math.floor(Math.random() * WORDS.length)];
+}
+/** Bun-friendly faker used inside factory `definition()`. */
+export function fake() {
+    return {
+        uuid: () => crypto.randomUUID(),
+        word: () => pickWord(),
+        words(count = 3) {
+            return Array.from({ length: count }, () => pickWord()).join(" ");
+        },
+        sentence() {
+            const text = this.words(6);
+            return text.charAt(0).toUpperCase() + text.slice(1) + ".";
+        },
+        firstName: () => pickWord().replace(/^./, (c) => c.toUpperCase()),
+        lastName: () => pickWord().replace(/^./, (c) => c.toUpperCase()),
+        name() {
+            return `${this.firstName()} ${this.lastName()}`;
+        },
+        email() {
+            return `${pickWord()}.${pickWord()}${Math.floor(Math.random() * 1000)}@example.test`;
+        },
+        number(max = 1000) {
+            return Math.floor(Math.random() * Math.max(1, max));
+        },
+        boolean: () => Math.random() >= 0.5,
+    };
+}
+function singularTable(table) {
+    if (table.endsWith("ies"))
+        return `${table.slice(0, -3)}y`;
+    if (table.endsWith("s"))
+        return table.slice(0, -1);
+    return table;
+}
+function guessRelationName(from, related) {
+    const base = related.name.replace(/Factory$/, "");
+    const singular = base.charAt(0).toLowerCase() + base.slice(1);
+    const plural = singular.endsWith("s") ? singular : `${singular}s`;
+    const parent = new from();
+    for (const candidate of [plural, singular]) {
+        try {
+            parent.related(candidate);
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    return plural;
+}
+export class Factory {
+    #count = 1;
+    #many = false;
+    #states = [];
+    #sequences = [];
+    #sequenceIndex = 0;
+    #afterMaking = [];
+    #afterCreating = [];
+    #has = [];
+    #for = [];
+    #hasAttached = [];
+    /** Public model class accessor for relationship factories. */
+    modelClass() {
+        return this.model();
+    }
+    definition() {
+        return {};
+    }
+    /** Number of models to make/create. */
+    count(amount) {
+        this.#count = amount;
+        this.#many = true;
+        return this;
+    }
+    /** Merge attribute overrides (object or callback) into every model. */
+    state(state) {
+        this.#states.push(state);
+        return this;
+    }
+    /**
+     * Cycle attribute sets across models.
+     * Sequence callbacks receive a 1-based index.
+     */
+    sequence(...states) {
+        this.#sequences.push(...states);
+        return this;
+    }
+    /** Run after an in-memory model is built (`make` / before persist). */
+    afterMaking(callback) {
+        this.#afterMaking.push(callback);
+        return this;
+    }
+    /** Run after a model is persisted (`create`). */
+    afterCreating(callback) {
+        this.#afterCreating.push(callback);
+        return this;
+    }
+    /**
+     * Create related models after the parent (`has(PostFactory.new().count(3))`).
+     */
+    has(factory, relationship) {
+        this.#has.push({ factory, relationship });
+        return this;
+    }
+    /**
+     * Associate a parent model / factory (`for(TeamFactory.new())`).
+     */
+    for(parent, relationship) {
+        this.#for.push({ parent, relationship });
+        return this;
+    }
+    /**
+     * Attach related models on a belongs-to-many after create.
+     */
+    hasAttached(related, pivot = {}, relationship) {
+        this.#hasAttached.push({ related, pivot, relationship });
+        return this;
+    }
+    /** `Factory::new()`. */
+    static new() {
+        return new this();
+    }
+    async #resolveAttributes(attributes = {}) {
+        let attrs = { ...(await this.definition()) };
+        for (const state of this.#states) {
+            const patch = typeof state === "function" ? await state(attrs) : state;
+            attrs = { ...attrs, ...patch };
+        }
+        if (this.#sequences.length > 0) {
+            this.#sequenceIndex += 1;
+            const seq = this.#sequences[(this.#sequenceIndex - 1) % this.#sequences.length];
+            const patch = typeof seq === "function" ? seq(this.#sequenceIndex) : seq;
+            attrs = { ...attrs, ...patch };
+        }
+        for (const spec of this.#for) {
+            const parentModel = spec.parent instanceof Factory
+                ? (await spec.parent.create())
+                : spec.parent;
+            const ParentCtor = parentModel.constructor;
+            const fkName = spec.relationship?.endsWith("_id")
+                ? spec.relationship
+                : spec.relationship
+                    ? `${spec.relationship}_id`
+                    : `${singularTable(ParentCtor.table)}_id`;
+            attrs[fkName] = parentModel[ParentCtor.primaryKey];
+        }
+        return { ...attrs, ...attributes };
+    }
+    async #createRelated(parent) {
+        const ParentCtor = parent.constructor;
+        const parentId = parent[ParentCtor.primaryKey];
+        for (const spec of this.#has) {
+            const RelatedCtor = spec.factory.modelClass();
+            const relName = spec.relationship ?? guessRelationName(ParentCtor, RelatedCtor);
+            let fk = `${singularTable(ParentCtor.table)}_id`;
+            let useAttach = false;
+            try {
+                const rel = parent.related(relName);
+                if (typeof rel.attach === "function") {
+                    useAttach = true;
+                }
+                else if (typeof rel.getForeignKeyName === "function") {
+                    fk = rel.getForeignKeyName();
+                }
+            }
+            catch {
+                // use default fk
+            }
+            if (useAttach) {
+                const related = await spec.factory.create();
+                const list = Array.isArray(related) ? related : [related];
+                const rel = parent.related(relName);
+                const ids = list.map((m) => m[m.constructor.primaryKey]);
+                await rel.attach(ids);
+                continue;
+            }
+            await spec.factory.state({ [fk]: parentId }).create();
+        }
+        for (const spec of this.#hasAttached) {
+            let models;
+            if (spec.related instanceof Factory) {
+                const created = await spec.related.create();
+                models = Array.isArray(created) ? created : [created];
+            }
+            else if (Array.isArray(spec.related)) {
+                models = spec.related;
+            }
+            else {
+                models = [spec.related];
+            }
+            if (models.length === 0)
+                continue;
+            const RelatedCtor = models[0].constructor;
+            const relName = spec.relationship ?? guessRelationName(ParentCtor, RelatedCtor);
+            const rel = parent.related(relName);
+            const ids = models.map((m) => m[m.constructor.primaryKey]);
+            await rel.attach(ids);
+            void spec.pivot;
+        }
+    }
+    /** Build an in-memory model instance (not persisted). */
+    async make(attributes = {}) {
+        const n = this.#count;
+        const many = this.#many;
+        this.#count = 1;
+        this.#many = false;
+        const ModelClass = this.model();
+        const items = [];
+        for (let i = 0; i < n; i++) {
+            const base = await this.#resolveAttributes(attributes);
+            const model = new ModelClass(base);
+            for (const cb of this.#afterMaking) {
+                await cb(model);
+            }
+            items.push(model);
+        }
+        return (many ? items : items[0]);
+    }
+    /** Persist model(s) via `Model.forceCreate` (factories set guarded columns too). */
+    async create(attributes = {}) {
+        const n = this.#count;
+        const many = this.#many;
+        this.#count = 1;
+        this.#many = false;
+        const ModelClass = this.model();
+        const items = [];
+        for (let i = 0; i < n; i++) {
+            const base = await this.#resolveAttributes(attributes);
+            const model = (await ModelClass.forceCreate(base));
+            for (const cb of this.#afterMaking) {
+                await cb(model);
+            }
+            for (const cb of this.#afterCreating) {
+                await cb(model);
+            }
+            await this.#createRelated(model);
+            items.push(model);
+        }
+        return (many ? items : items[0]);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { Model, ModelQuery, HasMany, HasManyThrough, HasOne, HasOneThrough, BelongsTo, BelongsToMany, MorphToMany, MorphMany, MorphOne, MorphTo, morphMap, clearMorphMap, eagerLoadModels, eagerLoadAggregates, ModelNotFoundException, LazyLoadingViolationException, MassAssignmentException, MissingAttributeException, resetModelStrictnessForTests, isModelCtor, Attribute, AsCollection, AsFluent, AsEnumCollection, resetModelEventsForTests, type ModelClass, type RelationFactory, type RelationsMap, type CastType, type CastDefinition, type EnumCast, type ModelEventName, type ModelEventListener, type ModelObserver, type ModelQueryOptions, type EagerAggregateSpec, type MorphToManyOptions, resolveConnection, } from "./model.js";
+export type { GlobalScopeCallback } from "./scopes.js";
+export { clearGlobalScopes } from "./scopes.js";
+export { UseBuilder, resolveModelBuilder, type ModelBuilderConstructor, } from "./decorators.js";
+export { HasUuids, HasUlids, HasFactory, SoftDeletes, Prunable, MassPrunable, prune, pruneAll, prunableModelClasses, massPrunableModelClasses, clearPrunableRegistries, uuid7, ulid, } from "./concerns.js";
+export { OrmCollection } from "./orm-collection.js";
+export { Factory, fake, type FactoryAttributes, type FactoryState, type FactorySequenceState, type FakeGenerator, } from "./factory.js";
+export { Pivot } from "./pivot.js";
+export { LengthAwarePaginator } from "@bunyad/database";
+export { Collection, collect } from "@bunyad/common";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { Model, ModelQuery, HasMany, HasManyThrough, HasOne, HasOneThrough, BelongsTo, BelongsToMany, MorphToMany, MorphMany, MorphOne, MorphTo, morphMap, clearMorphMap, eagerLoadModels, eagerLoadAggregates, ModelNotFoundException, LazyLoadingViolationException, MassAssignmentException, MissingAttributeException, resetModelStrictnessForTests, isModelCtor, Attribute, AsCollection, AsFluent, AsEnumCollection, resetModelEventsForTests, resolveConnection, } from "./model.js";
+export { clearGlobalScopes } from "./scopes.js";
+export { UseBuilder, resolveModelBuilder, } from "./decorators.js";
+export { HasUuids, HasUlids, HasFactory, SoftDeletes, Prunable, MassPrunable, prune, pruneAll, prunableModelClasses, massPrunableModelClasses, clearPrunableRegistries, uuid7, ulid, } from "./concerns.js";
+export { OrmCollection } from "./orm-collection.js";
+export { Factory, fake, } from "./factory.js";
+export { Pivot } from "./pivot.js";
+export { LengthAwarePaginator } from "@bunyad/database";
+export { Collection, collect } from "@bunyad/common";

package/dist/model-events.d.ts

@@ -0,0 +1,43 @@
+import type { Model } from "./model.js";
+/** Eloquent model lifecycle event names. */
+export type ModelEventName = "retrieved" | "creating" | "created" | "updating" | "updated" | "saving" | "saved" | "deleting" | "deleted" | "trashed" | "forceDeleting" | "forceDeleted" | "restoring" | "restored" | "replicating";
+export declare const MODEL_EVENT_NAMES: readonly ModelEventName[];
+/**
+ * Listener for a model event.
+ * Return `false` from a before-event (`creating`, `saving`, …) to cancel.
+ */
+export type ModelEventListener<T extends Model = Model> = (model: T) => void | boolean | Promise<void | boolean>;
+/** Observer object with optional methods named after events. */
+export type ModelObserver<T extends Model = Model> = {
+    [K in ModelEventName]?: (model: T) => void | boolean | Promise<void | boolean>;
+};
+type ModelCtor = abstract new (...args: never[]) => Model;
+/** Whether events are currently suppressed for this model class. */
+export declare function modelEventsDisabled(ctor: ModelCtor): boolean;
+/**
+ * Ensure `boot` / `booted` have run once for this model class.
+ * Call sites: first query, save, or `static::created(...)` registration.
+ */
+export declare function bootIfNotBooted(ctor: ModelCtor & {
+    boot?: () => void;
+    booted?: () => void;
+}): void;
+/** Register a listener for a model event on this class. */
+export declare function registerModelEvent(ctor: ModelCtor, event: ModelEventName, listener: ModelEventListener): void;
+/**
+ * Fire a model event. Returns `false` if a listener cancelled the operation.
+ * After-events (`created`, `saved`, …) ignore `false` return values for control flow
+ * but still run all listeners.
+ * No-listener path is synchronous so SQLite save/find skip Promise microtasks.
+ */
+export declare function fireModelEvent(model: Model, event: ModelEventName): boolean | Promise<boolean>;
+/** True when at least one listener is registered for this event. */
+export declare function hasModelEventListeners(ctor: ModelCtor, event: ModelEventName): boolean;
+export declare function hasAnyModelEventListeners(ctor: ModelCtor): boolean;
+/** Run `callback` with model events disabled for `ctor`. */
+export declare function withoutModelEvents<T>(ctor: ModelCtor, callback: () => T | Promise<T>): T | Promise<T>;
+/** Register an observer instance or class (Laravel `Model::observe`). */
+export declare function observeModel<T extends Model>(ctor: abstract new (...args: never[]) => T, observer: ModelObserver<T> | (new () => ModelObserver<T>) | Array<ModelObserver<T> | (new () => ModelObserver<T>)>): void;
+/** Test helper — clear boot state and listeners for a model class. */
+export declare function resetModelEventsForTests(ctor: ModelCtor): void;
+export {};

package/dist/model-events.js

@@ -0,0 +1,138 @@
+export const MODEL_EVENT_NAMES = [
+    "retrieved",
+    "creating",
+    "created",
+    "updating",
+    "updated",
+    "saving",
+    "saved",
+    "deleting",
+    "deleted",
+    "trashed",
+    "forceDeleting",
+    "forceDeleted",
+    "restoring",
+    "restored",
+    "replicating",
+];
+const booted = new WeakSet();
+const listeners = new WeakMap();
+const eventsDisabled = new WeakMap();
+function listenerMap(ctor) {
+    let map = listeners.get(ctor);
+    if (!map) {
+        map = new Map();
+        listeners.set(ctor, map);
+    }
+    return map;
+}
+/** Whether events are currently suppressed for this model class. */
+export function modelEventsDisabled(ctor) {
+    return (eventsDisabled.get(ctor) ?? 0) > 0;
+}
+/**
+ * Ensure `boot` / `booted` have run once for this model class.
+ * Call sites: first query, save, or `static::created(...)` registration.
+ */
+export function bootIfNotBooted(ctor) {
+    if (booted.has(ctor))
+        return;
+    booted.add(ctor);
+    ctor.boot?.();
+    ctor.booted?.();
+}
+/** Register a listener for a model event on this class. */
+export function registerModelEvent(ctor, event, listener) {
+    bootIfNotBooted(ctor);
+    const map = listenerMap(ctor);
+    const list = map.get(event) ?? [];
+    list.push({ listener });
+    map.set(event, list);
+}
+/**
+ * Fire a model event. Returns `false` if a listener cancelled the operation.
+ * After-events (`created`, `saved`, …) ignore `false` return values for control flow
+ * but still run all listeners.
+ * No-listener path is synchronous so SQLite save/find skip Promise microtasks.
+ */
+export function fireModelEvent(model, event) {
+    const ctor = model.constructor;
+    if (modelEventsDisabled(ctor))
+        return true;
+    const list = listeners.get(ctor)?.get(event);
+    if (!list || list.length === 0)
+        return true;
+    return fireModelEventList(model, event, list);
+}
+async function fireModelEventList(model, event, list) {
+    const isBefore = event.endsWith("ing") && event !== "replicating";
+    for (const entry of list) {
+        const result = await entry.listener(model);
+        if (isBefore && result === false)
+            return false;
+    }
+    return true;
+}
+/** True when at least one listener is registered for this event. */
+export function hasModelEventListeners(ctor, event) {
+    if (modelEventsDisabled(ctor))
+        return false;
+    const list = listeners.get(ctor)?.get(event);
+    return Boolean(list && list.length > 0);
+}
+export function hasAnyModelEventListeners(ctor) {
+    if (modelEventsDisabled(ctor))
+        return false;
+    const map = listeners.get(ctor);
+    if (!map)
+        return false;
+    for (const list of map.values()) {
+        if (list.length > 0)
+            return true;
+    }
+    return false;
+}
+/** Run `callback` with model events disabled for `ctor`. */
+export function withoutModelEvents(ctor, callback) {
+    eventsDisabled.set(ctor, (eventsDisabled.get(ctor) ?? 0) + 1);
+    const finish = () => {
+        const depth = (eventsDisabled.get(ctor) ?? 1) - 1;
+        if (depth <= 0)
+            eventsDisabled.delete(ctor);
+        else
+            eventsDisabled.set(ctor, depth);
+    };
+    try {
+        const result = callback();
+        if (result instanceof Promise) {
+            return result.finally(finish);
+        }
+        finish();
+        return result;
+    }
+    catch (error) {
+        finish();
+        throw error;
+    }
+}
+/** Register an observer instance or class (Laravel `Model::observe`). */
+export function observeModel(ctor, observer) {
+    const list = Array.isArray(observer) ? observer : [observer];
+    for (const item of list) {
+        const instance = typeof item === "function"
+            ? new item()
+            : item;
+        for (const event of MODEL_EVENT_NAMES) {
+            const method = instance[event];
+            if (typeof method === "function") {
+                registerModelEvent(ctor, event, (model) => method.call(instance, model));
+            }
+        }
+    }
+}
+/** Test helper — clear boot state and listeners for a model class. */
+export function resetModelEventsForTests(ctor) {
+    booted.delete(ctor);
+    listeners.delete(ctor);
+    eventsDisabled.delete(ctor);
+}

package/dist/model-helpers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared ORM helpers (Model / relations / eager / ModelQuery).
+ */
+import type { Connection } from "@bunyad/database";
+import type { ModelClass } from "./model.js";
+export declare function singular(name: string): string;
+/** Parse `relation as alias` strings. */
+export declare function parseRelationAlias(raw: string): {
+    relation: string;
+    alias?: string;
+};
+/** Constraint applied while eager-loading a relation (`with({ posts: (q) => … })`). */
+export type EagerRelationConstraint = (query: {
+    where: (...args: never[]) => unknown;
+    [key: string]: unknown;
+}) => void;
+/** Normalized eager-load entry (path + optional constraint). */
+export type NormalizedEagerRelation = {
+    name: string;
+    constraint?: EagerRelationConstraint;
+};
+/** Flatten `with('a', { b: true, c: fn }, ['d'])` into path + constraint entries. */
+export declare function normalizeWithRelations(relations: Array<string | string[] | Record<string, unknown>>): NormalizedEagerRelation[];
+/** Coerce string paths or normalized entries for eager-load callers. */
+export declare function coerceEagerRelations(relations: Array<string | NormalizedEagerRelation>): NormalizedEagerRelation[];
+export declare function usesSoftDeletes(model: ModelClass): boolean;
+export declare function deletedAtColumn(model: ModelClass): string;
+/** Soft-delete predicate for a quoted table/alias (empty when model is not soft-deleting). */
+export declare function softDeleteAliasSql(Related: ModelClass, aliasSql: string): string;
+/** Current timestamp in the active driver's storage form. */
+export declare function nowForConnection(connection?: Connection): Date | string;
+export declare function uniqueKeys(values: unknown[]): unknown[];

package/dist/model-helpers.js

@@ -0,0 +1,99 @@
+import { connections, dateTimeForStorage, wrapSqlName } from "@bunyad/database";
+export function singular(name) {
+    if (name.endsWith("ies"))
+        return `${name.slice(0, -3)}y`;
+    if (name.endsWith("s"))
+        return name.slice(0, -1);
+    return name;
+}
+/** Parse `relation as alias` strings. */
+export function parseRelationAlias(raw) {
+    const text = typeof raw === "string" ? raw : String(raw ?? "");
+    const m = text.match(/^(.+?)\s+as\s+(.+)$/i);
+    if (!m)
+        return { relation: text.trim() };
+    return { relation: m[1].trim(), alias: m[2].trim() };
+}
+/** Flatten `with('a', { b: true, c: fn }, ['d'])` into path + constraint entries. */
+export function normalizeWithRelations(relations) {
+    const out = [];
+    for (const rel of relations) {
+        if (typeof rel === "string") {
+            if (rel.trim())
+                out.push({ name: rel });
+            continue;
+        }
+        if (Array.isArray(rel)) {
+            for (const name of rel) {
+                if (typeof name === "string" && name.trim())
+                    out.push({ name });
+            }
+            continue;
+        }
+        if (rel && typeof rel === "object") {
+            for (const [name, value] of Object.entries(rel)) {
+                if (value === false || value == null)
+                    continue;
+                if (typeof name !== "string" || !name.trim())
+                    continue;
+                if (typeof value === "function") {
+                    out.push({
+                        name,
+                        constraint: value,
+                    });
+                }
+                else {
+                    out.push({ name });
+                }
+            }
+        }
+    }
+    return out;
+}
+/** Coerce string paths or normalized entries for eager-load callers. */
+export function coerceEagerRelations(relations) {
+    const out = [];
+    for (const rel of relations) {
+        if (typeof rel === "string") {
+            if (rel.trim())
+                out.push({ name: rel });
+        }
+        else if (rel?.name?.trim()) {
+            out.push(rel);
+        }
+    }
+    return out;
+}
+export function usesSoftDeletes(model) {
+    return model.softDeletes === true;
+}
+export function deletedAtColumn(model) {
+    return model.deletedAt ?? "deleted_at";
+}
+/** Soft-delete predicate for a quoted table/alias (empty when model is not soft-deleting). */
+export function softDeleteAliasSql(Related, aliasSql) {
+    if (!usesSoftDeletes(Related))
+        return "";
+    const dialect = Related.getConnection().dialect;
+    const col = wrapSqlName(dialect, deletedAtColumn(Related));
+    return ` AND ${aliasSql}.${col} IS NULL`;
+}
+/** Current timestamp in the active driver's storage form. */
+export function nowForConnection(connection) {
+    const driver = connection?.driver ?? connections.connection().driver ?? "sqlite";
+    return dateTimeForStorage(new Date(), driver);
+}
+export function uniqueKeys(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        if (value === undefined || value === null)
+            continue;
+        const key = String(value);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(value);
+    }
+    return out;
+}