@cleverbrush/knex-schema 3.0.1 → 4.0.0

package/dist/SchemaQueryBuilder.d.ts

@@ -1,7 +1,75 @@
 import type { InferType } from '@cleverbrush/schema';
-import { ObjectSchemaBuilder } from '@cleverbrush/schema';
+import { EXTRA_TYPE_BRAND, METHOD_LITERAL_BRAND, ObjectSchemaBuilder } from '@cleverbrush/schema';
 import type { Knex } from 'knex';
-import type { ColumnRef, InsertType, JoinManySpec, JoinOneSpec, WithJoinedMany, WithJoinedOne } from './types.js';
+import { POLYMORPHIC_TYPE_BRAND } from './extension.js';
+import type { ColumnRef, CursorPaginationResult, InsertType, JoinManySpec, JoinOneSpec, PaginationResult, SelectProjection, SelectSelector, WithJoinedMany, WithJoinedOne } from './types.js';
+/**
+ * Extracts the scope names registered on a schema via `.scope(name, fn)`.
+ * Returns `never` when no scopes are defined (making `.scoped()` uncallable).
+ * Falls back to `string` for `any`-typed schemas to preserve loose behaviour.
+ *
+ * @internal
+ */
+type ScopesOf<S> = S extends {
+    readonly [METHOD_LITERAL_BRAND]?: infer N;
+} ? Extract<N, string> : never;
+/**
+ * Extracts the named projection map from a schema type.
+ * Returns a `Record<name, readonly keys[]>` type where each key is a
+ * registered projection name and the value is the tuple of property keys.
+ * Returns `Record<never, never>` (no projections) when the schema has none,
+ * making `.projected()` uncallable on undecorated schemas.
+ *
+ * @internal
+ */
+type ProjectionsOf<S> = S extends {
+    readonly [EXTRA_TYPE_BRAND]?: infer P;
+} ? P extends Record<string, readonly string[]> ? P : Record<never, never> : Record<never, never>;
+/**
+ * Extracts the string-key union for a specific projection name from a schema
+ * type. This indirection is needed because TypeScript cannot directly index
+ * `ProjectionsOf<S>[K]` with `number` inside a generic function signature.
+ *
+ * @internal
+ */
+type ProjectionKeysOf<S, K extends keyof ProjectionsOf<S> & string> = ProjectionsOf<S>[K] extends readonly (infer T extends string)[] ? T : string;
+/**
+ * When a schema carries the `POLYMORPHIC_TYPE_BRAND` phantom type (set by
+ * `.withVariants()`), extract the discriminated-union result type from it.
+ * Otherwise fall back to `InferType<TLocalSchema>`.
+ *
+ * @internal
+ */
+type QueryResultType<TLocalSchema> = TLocalSchema extends {
+    readonly [POLYMORPHIC_TYPE_BRAND]?: infer U;
+} ? NonNullable<U> : InferType<TLocalSchema>;
+/**
+ * Intermediate builder returned by {@link SchemaQueryBuilder.onConflict}.
+ * Call `.merge()` or `.ignore()` to complete the upsert/insert-ignore operation.
+ *
+ * @internal
+ */
+export declare class OnConflictBuilder<TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>, TResult> {
+    #private;
+    /** @internal */
+    constructor(knex: Knex, localSchema: TLocalSchema, _parent: SchemaQueryBuilder<TLocalSchema, TResult>, conflictColumns: string[]);
+    /**
+     * Insert and merge (update) conflicting rows.
+     *
+     * @param data - Row to insert.
+     * @param updateData - Optional partial object of columns to update on
+     *   conflict. If omitted, all inserted columns are updated.
+     * @returns The resulting row.
+     */
+    merge(data: InsertType<TLocalSchema>, updateData?: Partial<InferType<TLocalSchema>>): Promise<TResult>;
+    /**
+     * Insert and silently ignore conflicts.
+     *
+     * @param data - Row to insert.
+     * @returns The row if inserted, or `undefined` if the conflict was ignored.
+     */
+    ignore(data: InsertType<TLocalSchema>): Promise<TResult | undefined>;
+}
 /**
  * Type-safe, schema-driven query builder for Knex.
  *
@@ -277,6 +345,36 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
      * @returns `this` for chaining.
      */
     whereExists(callback: Knex.QueryCallback | Knex.QueryBuilder): this;
+    /**
+     * Add a `WHERE NOT EXISTS (subquery)` clause.
+     * @param callback - A Knex query callback or sub-query builder.
+     * @returns `this` for chaining.
+     */
+    whereNotExists(callback: Knex.QueryCallback | Knex.QueryBuilder): this;
+    /**
+     * Add a PostgreSQL JSON path filter using `@?` / `@@` operators or
+     * a path-based equality test via `jsonb_path_query_first`.
+     *
+     * Only supported on `pg` clients — throws at runtime on others.
+     *
+     * @param column - Column reference for the `jsonb` column.
+     * @param path   - Dot-separated property path (e.g. `'a.b.c'`) or a
+     *   JSONPath expression string (e.g. `'$.a.b ? (@ == 1)'`).
+     * @param operator - Comparison operator (`=`, `!=`, `<`, `<=`, `>`, `>=`,
+     *   `@?`, `@@`). Use `@?` / `@@` for JSONPath existence / predicate tests.
+     * @param value  - The right-hand side value. Ignored for `@?` and `@@`.
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * // Filter rows where data->>'status' = 'active'
+     * query(db, Schema).whereJsonPath(t => t.data, 'status', '=', 'active');
+     *
+     * // JSONPath existence
+     * query(db, Schema).whereJsonPath(t => t.data, '$.tags[*] ? (@ == "sale")', '@?');
+     * ```
+     */
+    whereJsonPath(column: ColumnRef<TLocalSchema>, path: string, operator?: string, value?: any): this;
     /**
      * Order the results by a column.
      * @param column - Column reference or raw expression.
@@ -335,6 +433,22 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
      * @returns `this` for chaining.
      */
     select(...columns: (ColumnRef<TLocalSchema> | Knex.Raw)[]): this;
+    /**
+     * DTO projection: select multiple aliased columns at once via a
+     * descriptor record. Returns a query whose result rows match the
+     * shape of the selector's return value (each value typed as the
+     * inferred schema-property type).
+     *
+     * @example
+     * ```ts
+     * const dtos = await query(db, UserSchema)
+     *     .where(t => t.id, '>', 0)
+     *     .select(t => ({ id: t.id, n: t.name }))
+     *     .execute();
+     * // dtos: { id: number; n: string }[]
+     * ```
+     */
+    select<TSel extends SelectSelector<TLocalSchema>>(selector: TSel): SchemaQueryBuilder<TLocalSchema, SelectProjection<ReturnType<TSel>>>;
     /**
      * Add `DISTINCT` to the select clause. Duplicate rows are eliminated.
      * @param columns - One or more column references or raw expressions.
@@ -398,6 +512,53 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
      * @returns The full inserted rows in insertion order.
      */
     insertMany(data: InsertType<TLocalSchema>[]): Promise<TResult[]>;
+    /**
+     * Insert a row (or rows) with an `ON CONFLICT` clause.
+     *
+     * Returns a chainable object with `.merge()` and `.ignore()` methods.
+     *
+     * - `.merge(updateData?)` — updates the conflicting row with the provided
+     *   fields (or all insert fields if omitted).
+     * - `.ignore()` — skips the insert when a conflict occurs (INSERT IGNORE).
+     *
+     * @param conflictColumns - Column references that define the conflict target.
+     * @returns A chainable conflict builder.
+     *
+     * @example
+     * ```ts
+     * // Upsert: insert or update on conflict
+     * await query(db, UserSchema)
+     *     .onConflict(t => t.email)
+     *     .merge({ name: 'Bob' });
+     *
+     * // Insert and ignore on conflict
+     * await query(db, UserSchema)
+     *     .onConflict(t => t.email)
+     *     .ignore();
+     * ```
+     */
+    onConflict(...conflictColumns: ColumnRef<TLocalSchema>[]): OnConflictBuilder<TLocalSchema, TResult>;
+    /**
+     * Insert or update a row based on a conflict target (upsert shorthand).
+     *
+     * Equivalent to calling `.onConflict(conflictColumns).merge(updateData)`.
+     *
+     * @param data - The row data to insert.
+     * @param opts - `{ conflictColumns, updateColumns? }`.
+     * @returns The resulting row (inserted or updated).
+     *
+     * @example
+     * ```ts
+     * const user = await query(db, UserSchema).upsert(
+     *     { email: 'alice@example.com', name: 'Alice' },
+     *     { conflictColumns: [t => t.email], updateColumns: [t => t.name] }
+     * );
+     * ```
+     */
+    upsert(data: InsertType<TLocalSchema>, opts: {
+        conflictColumns: ColumnRef<TLocalSchema>[];
+        updateColumns?: ColumnRef<TLocalSchema>[];
+    }): Promise<TResult>;
     /**
      * Update all rows that match the current `WHERE` clause and return the
      * updated records.
@@ -418,7 +579,12 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
     update(data: Partial<InferType<TLocalSchema>>): Promise<TResult[]>;
     /**
      * Delete all rows that match the current `WHERE` clause.
-     * @returns The number of rows deleted.
+     *
+     * If the schema has soft-delete enabled via `.softDelete()`, this performs
+     * an `UPDATE SET deleted_at = NOW()` instead of a real `DELETE`.
+     * Use {@link hardDelete} for permanent deletion.
+     *
+     * @returns The number of rows deleted (or soft-deleted).
      *
      * @example
      * ```ts
@@ -426,6 +592,53 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
      * ```
      */
     delete(): Promise<number>;
+    /**
+     * Bulk-insert many rows in chunks. The default chunk size of `500` keeps
+     * comfortably below Postgres' parameter-count limit of 65535. The chunk
+     * size also auto-shrinks when the number of bindings per row would
+     * exceed that ceiling.
+     *
+     * When `opts.onConflict` is supplied each chunk is wrapped in an
+     * `INSERT ... ON CONFLICT` clause:
+     *
+     * - `'ignore'` — `ON CONFLICT (...) DO NOTHING`
+     * - `'merge'`  — `ON CONFLICT (...) DO UPDATE SET ...` (uses `conflictColumns` as
+     *   the conflict target and updates every inserted column).
+     *
+     * `beforeInsert` / `afterInsert` hooks fire per row, identically to
+     * {@link insertMany}.
+     *
+     * @returns The inserted rows (excluding rows skipped by `'ignore'`).
+     */
+    bulkInsert(rows: InsertType<TLocalSchema>[], opts?: {
+        chunkSize?: number;
+        onConflict?: 'ignore' | 'merge';
+        conflictColumns?: ColumnRef<TLocalSchema>[];
+    }): Promise<TResult[]>;
+    /**
+     * Bulk-upsert many rows in chunks. Equivalent to
+     * `.bulkInsert(rows, { onConflict: 'merge', conflictColumns })`.
+     */
+    bulkUpsert(rows: InsertType<TLocalSchema>[], opts: {
+        conflictColumns: ColumnRef<TLocalSchema>[];
+        chunkSize?: number;
+    }): Promise<TResult[]>;
+    /**
+     * Bulk-update many rows in a single SQL statement using a CASE
+     * expression keyed on the entity's primary key.
+     *
+     * Each entry's `where` clause must fully match the entity's primary key
+     * columns (single or composite). Updates that touch different columns
+     * are coalesced into one statement; rows whose PK appears in `updates`
+     * but whose `set` does not contain a given column retain their existing
+     * value.
+     *
+     * @returns The number of rows affected.
+     */
+    bulkUpdate(updates: ReadonlyArray<{
+        where: Partial<InferType<TLocalSchema>>;
+        set: Partial<InferType<TLocalSchema>>;
+    }>): Promise<number>;
     /**
      * Escape hatch: apply any Knex method to the underlying base query.
      *
@@ -472,6 +685,228 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
      * ```
      */
     transacting(trx: Knex.Transaction): SchemaQueryBuilder<TLocalSchema, TResult>;
+    /**
+     * Eager-load a named relation defined via `.hasMany()`, `.belongsTo()`,
+     * `.hasOne()`, or `.belongsToMany()` on the schema.
+     *
+     * @param relationName - The relation name passed to the schema's relation method.
+     * @param customize - Optional callback to customise the foreign query
+     *   (e.g. add ordering, limits).
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * const posts = await query(db, PostWithRelations)
+     *     .include('author')
+     *     .include('tags');
+     * ```
+     */
+    include(relationName: string, customize?: (q: SchemaQueryBuilder<any, any>) => void): this;
+    /**
+     * Eager-load a named relation declared inside a `withVariants` variant spec.
+     *
+     * The relation is loaded via a LEFT JOIN on the variant's alias table and
+     * only populated on rows whose discriminator matches `variantKey`.
+     *
+     * @param variantKey - The variant key (e.g. `'assigned'`).
+     * @param relationName - The relation name declared in `variants[key].relations`.
+     * @param customize - Optional callback to restrict which columns are
+     *   selected from the foreign table (scope / projection).
+     *
+     * @example
+     * ```ts
+     * await query(db, TodoActivity)
+     *   .includeVariant('assigned', 'assignee', q => q.projected('summary'));
+     * ```
+     */
+    includeVariant(variantKey: string, relationName: string, customize?: (q: SchemaQueryBuilder<any, any>) => void): this;
+    /**
+     * Apply a named scope defined on the schema via `.scope(name, fn)`.
+     *
+     * The `name` parameter is constrained to the literal scope names registered
+     * on the schema, so IDEs show only valid completions and typos are caught
+     * at compile time.
+     *
+     * @param name - The scope name.
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * await query(db, Post).scoped('published').scoped('recent');
+     * ```
+     */
+    /**
+     * Apply a **named projection** defined on the schema via
+     * `.projection(name, columns)`.
+     *
+     * Calling `.projected()` on the query builder does two things:
+     * 1. Restricts the SQL `SELECT` clause to the columns registered under
+     *    `name` (SQL column names are resolved via `.hasColumnName()`).
+     * 2. Narrows the TypeScript result row type to `Pick<Row, Keys>` so
+     *    accessing columns outside the projection is a compile-time error.
+     *
+     * The `name` parameter is constrained to the literal projection names
+     * registered on the schema — TypeScript will report an error for any
+     * unregistered name.
+     *
+     * Calling `.projected()` after `.select()`, any aggregate method
+     * (`.count()`, `.min()`, etc.), or a second `.projected()` call throws
+     * at runtime with a clear error message.
+     *
+     * @param name - The projection name.
+     * @returns A new builder whose result type is `Pick<Row, ProjectionKeys>`.
+     *
+     * @example
+     * ```ts
+     * const PostSchema = object({ id: number(), title: string(), body: string() })
+     *   .hasTableName('posts')
+     *   .projection('summary', 'id', 'title');
+     *
+     * const rows = await query(db, PostSchema)
+     *   .scoped('published')
+     *   .projected('summary');
+     * // rows: Array<Pick<Post, 'id' | 'title'>>
+     * // rows[0].body  // ← TS error: not in projection
+     * ```
+     *
+     * @see {@link ddlExtension} `.projection()` for schema-side definition.
+     */
+    projected<K extends keyof ProjectionsOf<TLocalSchema> & string>(name: K): SchemaQueryBuilder<TLocalSchema, Pick<TResult, ProjectionKeysOf<TLocalSchema, K> & keyof TResult>>;
+    scoped<K extends ScopesOf<TLocalSchema>>(name: K): this;
+    /**
+     * Bypass the default scope (and soft-delete scope) for this query.
+     *
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * await query(db, Post).unscoped().where(t => t.id, 1);
+     * ```
+     */
+    unscoped(): this;
+    /**
+     * Add a WHERE condition that applies **only to rows matching a specific
+     * variant** of a polymorphic schema. Rows for other variants pass through
+     * unaffected (the condition is ORed away for non-matching discriminator values).
+     *
+     * The column name is resolved against the **variant's** schema properties.
+     *
+     * Only valid on a polymorphic schema (created via `.withVariants()`).
+     *
+     * @param key - The discriminator value identifying the variant (e.g. `'image'`).
+     * @param column - Property key on the variant's schema (e.g. `'width'`).
+     * @param operator - SQL comparison operator (`'='`, `'>'`, `'<'`, `'like'`, etc.).
+     * @param value - The value to compare against.
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * // Return all documents and only images wider than 1024 px
+     * const files = await query(db, FileSchema)
+     *     .whereVariant('image', 'width', '>', 1024);
+     * ```
+     */
+    whereVariant(key: string, column: string, operator: string, value: any): this;
+    /**
+     * Restrict the query to only return rows for the specified variant keys.
+     *
+     * Adds `WHERE <discriminator> IN (...)` to the query and skips the LEFT
+     * JOINs for excluded variants. This is more efficient than filtering after
+     * loading all variants.
+     *
+     * Only valid on a polymorphic schema (created via `.withVariants()`).
+     *
+     * @param keys - Discriminator values to include (e.g. `['image', 'document']`).
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * const images = await query(db, FileSchema).selectVariants(['image']);
+     * // images: Array<{ id; name; type: 'image'; width; height; format }>
+     * ```
+     */
+    selectVariants(keys: string[]): this;
+    /**
+     * Include soft-deleted rows in the results.
+     *
+     * By default, schemas with `.softDelete()` automatically filter out
+     * rows where `deleted_at IS NOT NULL`. Call `.withDeleted()` to
+     * include them.
+     *
+     * @returns `this` for chaining.
+     */
+    withDeleted(): this;
+    /**
+     * Return only soft-deleted rows (`WHERE deleted_at IS NOT NULL`).
+     *
+     * @returns `this` for chaining.
+     */
+    onlyDeleted(): this;
+    /**
+     * Permanently delete rows matching the current WHERE clause, bypassing
+     * the soft-delete mechanism.
+     *
+     * @returns The number of rows deleted.
+     */
+    hardDelete(): Promise<number>;
+    /**
+     * Restore soft-deleted rows by setting `deleted_at = NULL`.
+     *
+     * @returns The restored rows.
+     */
+    restore(): Promise<TResult[]>;
+    /**
+     * Execute an offset-based paginated query.
+     *
+     * Runs a count query and a data query in parallel. Returns the page data
+     * along with pagination metadata.
+     *
+     * @param opts - `{ page, pageSize }` — 1-based page number and page size.
+     * @returns A {@link PaginationResult} with data, total count, and page info.
+     *
+     * @example
+     * ```ts
+     * const page = await query(db, Post)
+     *     .where(t => t.status, 'published')
+     *     .paginate({ page: 2, pageSize: 20 });
+     * // page.data, page.total, page.totalPages, page.hasNextPage, ...
+     * ```
+     */
+    paginate(opts: {
+        page: number;
+        pageSize: number;
+    }): Promise<PaginationResult<TResult>>;
+    /**
+     * Execute a cursor-based (keyset) paginated query.
+     *
+     * More efficient than offset pagination for large datasets. Fetches one
+     * extra row to determine whether more data exists.
+     *
+     * @param opts - `{ cursor, limit, column?, direction? }`.
+     * @returns A {@link CursorPaginationResult} with data, next cursor, and
+     *   `hasMore` flag.
+     *
+     * @example
+     * ```ts
+     * const page = await query(db, Post)
+     *     .orderBy(t => t.createdAt, 'desc')
+     *     .paginateAfter({ cursor: lastCreatedAt, limit: 20 });
+     * ```
+     */
+    paginateAfter(opts: {
+        cursor?: any;
+        limit: number;
+        column?: ColumnRef<TLocalSchema>;
+        direction?: 'asc' | 'desc';
+    }): Promise<CursorPaginationResult<TResult>>;
+    /**
+     * Add a raw SQL expression to the SELECT clause.
+     *
+     * @param sql - Raw SQL (e.g. `'*, ts_rank(vector, query) AS rank'`).
+     * @param bindings - Optional parameter bindings.
+     * @returns `this` for chaining.
+     */
+    selectRaw(sql: string, bindings?: any[]): this;
     /**
      * Return the raw SQL string that would be executed, for debugging.
      * Does not execute the query against the database.
@@ -511,6 +946,20 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
      * ```
      */
     first(): Promise<TResult | undefined>;
+    /**
+     * Execute the query and return an array of values for a single column.
+     *
+     * @param column - Column reference (property accessor or string key) for
+     *   the column whose values should be returned.
+     * @returns A promise resolving to an array of values for that column.
+     *
+     * @example
+     * ```ts
+     * const names = await query(db, UserSchema).pluck(t => t.name);
+     * // names: string[]
+     * ```
+     */
+    pluck<K extends keyof TResult & string>(column: ColumnRef<TLocalSchema>): Promise<TResult[K][]>;
     /**
      * Thenable implementation — allows the builder to be awaited directly
      * without calling {@link execute} explicitly.
@@ -546,7 +995,7 @@ export declare class SchemaQueryBuilder<TLocalSchema extends ObjectSchemaBuilder
  * const users = await query(db, UserSchema).where(t => t.name, 'like', 'A%');
  * ```
  */
-export declare function query<TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(knex: Knex, schema: TLocalSchema): SchemaQueryBuilder<TLocalSchema, InferType<TLocalSchema>>;
+export declare function query<TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(knex: Knex, schema: TLocalSchema): SchemaQueryBuilder<TLocalSchema, QueryResultType<TLocalSchema>>;
 /**
  * Create a typed {@link SchemaQueryBuilder} from an existing Knex query builder.
  *
@@ -565,11 +1014,11 @@ export declare function query<TLocalSchema extends ObjectSchemaBuilder<any, any,
  * const activeUsers = await query(db, UserSchema, base).where(t => t.age, '>', 18);
  * ```
  */
-export declare function query<TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(knex: Knex, schema: TLocalSchema, baseQuery: Knex.QueryBuilder): SchemaQueryBuilder<TLocalSchema, InferType<TLocalSchema>>;
+export declare function query<TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(knex: Knex, schema: TLocalSchema, baseQuery: Knex.QueryBuilder): SchemaQueryBuilder<TLocalSchema, QueryResultType<TLocalSchema>>;
 /** Bound query function returned by {@link createQuery}. */
 export interface BoundQuery {
-    <TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(schema: TLocalSchema): SchemaQueryBuilder<TLocalSchema, InferType<TLocalSchema>>;
-    <TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(schema: TLocalSchema, baseQuery: Knex.QueryBuilder): SchemaQueryBuilder<TLocalSchema, InferType<TLocalSchema>>;
+    <TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(schema: TLocalSchema): SchemaQueryBuilder<TLocalSchema, QueryResultType<TLocalSchema>>;
+    <TLocalSchema extends ObjectSchemaBuilder<any, any, any, any, any, any, any>>(schema: TLocalSchema, baseQuery: Knex.QueryBuilder): SchemaQueryBuilder<TLocalSchema, QueryResultType<TLocalSchema>>;
     /**
      * Return a version of this bound factory whose queries all run within the
      * given Knex transaction. Equivalent to calling `.transacting(trx)` on
@@ -638,3 +1087,4 @@ export interface BoundQuery {
  * ```
  */
 export declare function createQuery(knexInstance: Knex): BoundQuery;
+export {};

package/dist/chunk-V4TH6K42.js

@@ -0,0 +1,2 @@
+import{arrayExtensions as p,defineExtension as d,NumberSchemaBuilder as x,numberExtensions as S,ObjectSchemaBuilder as g,StringSchemaBuilder as b,SYMBOL_SCHEMA_PROPERTY_DESCRIPTOR as E,stringExtensions as B,withExtensions as f}from"@cleverbrush/schema";import{EXTRA_TYPE_BRAND as Q,METHOD_LITERAL_BRAND as W}from"@cleverbrush/schema";var D=Symbol.for("@cleverbrush/knex-schema:primaryKey"),P=Symbol.for("@cleverbrush/knex-schema:compositePrimaryKey"),v=Symbol.for("@cleverbrush/knex-schema:polymorphicType");function r(n){return this.withExtension("columnName",n)}function T(n){return this.withExtension("tableName",n)}var w=d({string:{hasColumnName(n){return r.call(this,n)}},number:{hasColumnName(n){return r.call(this,n)}},boolean:{hasColumnName(n){return r.call(this,n)}},date:{hasColumnName(n){return r.call(this,n)}},any:{hasColumnName(n){return r.call(this,n)}},func:{hasColumnName(n){return r.call(this,n)}},array:{hasColumnName(n){return r.call(this,n)}},union:{hasColumnName(n){return r.call(this,n)}},generic:{hasColumnName(n){return r.call(this,n)}},object:{hasTableName(n){return T.call(this,n)}}}),R=d({number:{references(n,e="id"){return this.withExtension("references",{table:n,column:e})},onDelete(n){return this.withExtension("onDelete",n)},onUpdate(n){return this.withExtension("onUpdate",n)},defaultTo(n){return this.withExtension("defaultTo",n)},index(n){return this.withExtension("index",n??!0)},unique(n){return this.withExtension("unique",n??!0)},columnType(n){return this.withExtension("columnType",n)},bigint(){return this.withExtension("columnType","bigint")},smallint(){return this.withExtension("columnType","smallint")},decimal(n,e){return this.withExtension("columnType",`decimal(${n},${e})`)},defaultToRaw(n){return this.withExtension("defaultTo",{raw:n})},rowVersion(n){return this.withExtension("rowVersion",{strategy:n?.strategy??"increment"})}},string:{columnType(n){return this.withExtension("columnType",n)},text(){return this.withExtension("columnType","text")},asUuid(){return this.withExtension("columnType","uuid")},citext(){return this.withExtension("columnType","citext")},jsonb(){return this.withExtension("columnType","jsonb")},tsvector(){return this.withExtension("columnType","tsvector")},references(n,e="id"){return this.withExtension("references",{table:n,column:e})},onDelete(n){return this.withExtension("onDelete",n)},onUpdate(n){return this.withExtension("onUpdate",n)},unique(n){return this.withExtension("unique",n??!0)},index(n){return this.withExtension("index",n??!0)},defaultTo(n){return this.withExtension("defaultTo",n)},check(n){return this.withExtension("check",n)},defaultToRaw(n){return this.withExtension("defaultTo",{raw:n})},rowVersion(){return this.withExtension("rowVersion",{strategy:"manual"})}},boolean:{defaultTo(n){return this.withExtension("defaultTo",n)},columnType(n){return this.withExtension("columnType",n)},index(n){return this.withExtension("index",n??!0)},unique(n){return this.withExtension("unique",n??!0)}},date:{defaultTo(n){return this.withExtension("defaultTo",n)},columnType(n){return this.withExtension("columnType",n)},index(n){return this.withExtension("index",n??!0)},defaultToRaw(n){return this.withExtension("defaultTo",{raw:n})},timestamptz(){return this.withExtension("columnType","timestamptz")},dateOnly(){return this.withExtension("columnType","date")},rowVersion(){return this.withExtension("rowVersion",{strategy:"timestamp"})}},object:{columnType(n){return this.withExtension("columnType",n)},jsonb(){return this.withExtension("columnType","jsonb")},json(){return this.withExtension("columnType","json")},hasIndex(n,e){let a=this.getExtension("indexes")??[];return this.withExtension("indexes",[...a,{columns:n,...e}])},hasUnique(n,e){let a=this.getExtension("uniques")??[];return this.withExtension("uniques",[...a,{columns:n,name:e}])},hasCheck(n){let e=this.getExtension("checks")??[];return this.withExtension("checks",[...e,n])},hasRawColumn(n,e){let a=this.getExtension("rawColumns")??[];return this.withExtension("rawColumns",[...a,{name:n,definition:e}])},hasRawIndex(n){let e=this.getExtension("rawIndexes")??[];return this.withExtension("rawIndexes",[...e,n])},hasMany(n,e){let a=this.getExtension("relations")??[];return this.withExtension("relations",[...a,{type:"hasMany",name:n,...e}])},hasOne(n,e){let a=this.getExtension("relations")??[];return this.withExtension("relations",[...a,{type:"hasOne",name:n,...e}])},belongsTo(n,e){let a=this.getExtension("relations")??[];return this.withExtension("relations",[...a,{type:"belongsTo",name:n,...e}])},belongsToMany(n,e){let a=this.getExtension("relations")??[];return this.withExtension("relations",[...a,{type:"belongsToMany",name:n,...e}])},hasTimestamps(n){return this.withExtension("timestamps",{createdAt:n?.createdAt??"created_at",updatedAt:n?.updatedAt??"updated_at"})},softDelete(n){return this.withExtension("softDelete",{column:n?.column??"deleted_at"})},scope(n,e){let a=this.getExtension("scopes")??{};return this.withExtension("scopes",{...a,[n]:e})},projection(n,...e){let a=g.getPropertiesFor(this),y=e.map(h=>{if(typeof h=="string")return h;let t=h(a)[E];if(!t)throw new Error(`projection('${n}'): each accessor must return a valid PropertyDescriptor. Use \`t => t.propName\`.`);if(typeof t.propertyName!="string")throw new Error(`projection('${n}'): could not resolve property name from descriptor. Ensure the accessor returns a top-level property descriptor.`);return t.propertyName}),o=this.getExtension("projections")??{};if(Object.hasOwn(o,n))throw new Error(`projection('${n}'): a projection with this name is already registered on this schema. Each projection name must be unique.`);return this.withExtension("projections",{...o,[n]:{keys:y}})},defaultScope(n){return this.withExtension("defaultScope",n)},beforeInsert(n){let e=this.getExtension("beforeInsert")??[];return this.withExtension("beforeInsert",[...e,n])},afterInsert(n){let e=this.getExtension("afterInsert")??[];return this.withExtension("afterInsert",[...e,n])},beforeUpdate(n){let e=this.getExtension("beforeUpdate")??[];return this.withExtension("beforeUpdate",[...e,n])},beforeDelete(n){let e=this.getExtension("beforeDelete")??[];return this.withExtension("beforeDelete",[...e,n])}}});function I(n,e,a){let y={},o=[];for(let[i,t]of Object.entries(a)){let c=t.schema,m=c.introspect().properties??{};if(e in m){let l=m[e].introspect().equalsTo;if(l===void 0)throw new Error(`withVariants: variant "${i}" declares discriminator property "${e}" but it has no literal value \u2014 use string('${i}') instead of string()`);if(l!==i)throw new Error(`withVariants: variant "${i}" declares discriminator "${e}" = string('${l}') but the map key is '${i}' \u2014 they must match`)}let u;if(t.storage==="cti"){if(u=c.getExtension("tableName"),!u)throw new Error(`withVariants: CTI variant "${i}" schema must have .hasTableName() configured`);if(!t.foreignKeyColumn)throw new Error(`withVariants: CTI variant "${i}" must specify foreignKey (the FK property accessor on the variant schema)`)}y[i]={storage:t.storage,schema:c,foreignKey:t.foreignKeyColumn,tableName:u,allowOrphan:t.allowOrphan??!1,enforceCheck:t.enforceCheck??!1,relations:t.relations??[]},o.push(c)}let h={discriminatorKey:e,variants:y};return n.withExtension("variants",h).withExtension("polymorphicVariants",o)}var s=f(B,S,p,w,R),_=s.string,K=s.number,V=s.boolean,F=s.date,q=s.object,k=s.array,M=s.union,Y=s.func,U=s.any;(()=>{let n=x.prototype;typeof n.primaryKey!="function"&&(n.primaryKey=function(y){return this.withExtension("primaryKey",{autoIncrement:y?.autoIncrement??!0})});let e=b.prototype;typeof e.primaryKey!="function"&&(e.primaryKey=function(){return this.withExtension("primaryKey",{autoIncrement:!1})});let a=g.prototype;typeof a.hasPrimaryKey!="function"&&(a.hasPrimaryKey=function(y){return this.withExtension("compositePrimaryKey",y)})})();function $(n,e){let a=n.getExtension("columnName");return typeof a=="string"?a:e}function L(n){let e=n.getExtension("tableName");if(typeof e!="string")throw new Error('Schema does not have a table name. Use .hasTableName("table_name") to set one.');return e}function H(n){return n.getExtension("projections")??{}}function X(n){let e=n.getExtension("variants");return e??null}function z(n){return n.getExtension("polymorphicVariants")??[]}export{D as a,P as b,v as c,w as d,R as e,I as f,_ as g,K as h,V as i,F as j,q as k,k as l,M as m,Y as n,U as o,$ as p,L as q,H as r,X as s,z as t,Q as u,W as v};
+//# sourceMappingURL=chunk-V4TH6K42.js.map