@tstdl/base 0.93.36 → 0.93.38

package/source/orm/query/base.ts

@@ -1,269 +0,0 @@
-import type { SQL, SQLWrapper } from 'drizzle-orm';
-import type { UnionToIntersection } from 'type-fest';
-
-import type { Geometry } from '#/types/geo-json.js';
-import type { Flatten, Record } from '#/types/index.js';
-import type { UntaggedDeep } from '#/types/tagged.js';
-import type { BaseEntity } from '../entity.js';
-import type { TargetColumnPath } from '../repository.types.js';
-import { paradeComparisonQueryTypes, paradeSpecialQueryTypes, type ParadeComparisonQuery, type ParadeSearchQuery, type ParadeSpecialQuery } from './parade.js';
-
-/** Represents a logical query combining multiple sub-queries (e.g., $and, $or, $nor). */
-export type LogicalQuery<T = any> = LogicalAndQuery<T> | LogicalOrQuery<T> | LogicalNorQuery<T>;
-
-/** Union of keys representing logical query operators ('$and', '$or', '$nor'). */
-export type LogicalQueryTypes = keyof (LogicalAndQuery & LogicalOrQuery & LogicalNorQuery);
-
-/** Array containing all valid logical query operator keys. */
-export const allLogicalQueryTypes: LogicalQueryTypes[] = ['$and', '$or', '$nor'];
-
-/** Represents the body of a comparison query, mapping field paths to comparison operators or values. Allows nested structures. */
-export type ComparisonQueryBody<T = any> = { [P in keyof T]?: T[P] extends Record ? ComparisonQueryBody<T[P]> : ComparisonQueryOrValue<T[P]> } & Record<ComparisonQueryOrValue>;
-
-/** Represents either a full comparison query object or a direct value for equality comparison. */
-export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | ComparisonValue<T>;
-
-/** Represents a comparison query using various operators like $eq, $ne, $gt, $in, etc. */
-export type ComparisonQuery<T = any> = Partial<
-  & ComparisonAndQuery<T>
-  & ComparisonOrQuery<T>
-  & ComparisonNotQuery<T>
-  & ComparisonEqualsQuery<T>
-  & ComparisonNotEqualsQuery<T>
-  & ComparisonExistsQuery
-  & ComparisonItemQuery<T>
-  & ComparisonInQuery<T>
-  & ComparisonNotInQuery<T>
-  & ComparisonAllQuery<T>
-  & ComparisonGreaterThanQuery<T>
-  & ComparisonGreaterThanOrEqualsQuery<T>
-  & ComparisonLessThanQuery<T>
-  & ComparisonLessThanOrEqualsQuery<T>
-  & ComparisonRegexQuery
-  & ComparisonTsVectorQuery
-  & ComparisonTrigramQuery
-  & ParadeComparisonQuery
-  & ComparisonGeoShapeQuery
-  & ComparisonGeoDistanceQuery
->;
-
-export type TsVectorParser = 'raw' | 'plain' | 'phrase' | 'websearch';
-export type TsVectorWeight = 'A' | 'B' | 'C' | 'D';
-export type TrigramSimilarityType = 'phrase' | 'word' | 'strict-word';
-
-/** Union of keys representing comparison query operators. */
-export type ComparisonQueryTypes = keyof ComparisonQuery;
-
-/** Array containing all valid comparison query operator keys. */
-export const allComparisonQueryTypes: ComparisonQueryTypes[] = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$tsvector', '$trigram', '$geoDistance', '$geoShape', ...paradeComparisonQueryTypes];
-
-/** Represents specialized query types beyond simple comparisons. */
-export type SpecialQuery<T extends BaseEntity = BaseEntity> = FullTextSearchQuery<T> | ParadeSpecialQuery<T>;
-
-export type FullTextSearchQuery<T extends BaseEntity = BaseEntity> =
-  | TsVectorSearchQuery<T>
-  | TrigramSearchQuery<T>
-  | ParadeSearchQuery<T>;
-
-/** Union of keys representing special query operators. */
-export type SpecialQueryTypes = keyof UnionToIntersection<SpecialQuery>;
-
-/** Array containing all valid special query operator keys. */
-export const allSpecialQueryTypes: SpecialQueryTypes[] = ['$tsvector', '$trigram', ...paradeSpecialQueryTypes];
-
-/**
- * Represents a complete query, which can be either a raw Drizzle SQLWrapper
- * or a structured query object using logical and comparison operators.
- * @template T - The type of the entity being queried.
- */
-export type Query<T = any> = SQLWrapper | QueryObject<Extract<UntaggedDeep<T>, BaseEntity>>;
-
-/** Represents a structured query object, combining logical, comparison, and special queries. */
-export type QueryObject<T extends BaseEntity> = LogicalQuery<T> | Partial<SpecialQuery<T>> | ComparisonQueryBody<T>;
-
-/** Union of all possible query operator keys (logical, comparison, special). */
-export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
-
-/** Array containing all valid query operator keys. */
-export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
-
-/** Represents an AND logical query. All sub-queries must be true. */
-export type LogicalAndQuery<T = any> = {
-  $and: readonly Query<T>[],
-};
-
-/** Represents an OR logical query. At least one sub-query must be true. */
-export type LogicalOrQuery<T = any> = {
-  $or: readonly Query<T>[],
-};
-
-/** Represents a NOR logical query. All sub-queries must be false. */
-export type LogicalNorQuery<T = any> = {
-  $nor: readonly Query<T>[],
-};
-
-/** Represents a value used in comparisons, can be a direct value, a flattened value, or a Drizzle SQLWrapper. */
-export type ComparisonValue<T> = T | Flatten<T> | SQLWrapper;
-
-/** Represents a comparison value that can also include a RegExp for string comparisons. */
-export type ComparisonValueWithRegex<T> = T extends string
-  ? ComparisonValue<T | RegExp>
-  : T extends readonly string[]
-  ? ComparisonValue<readonly (Flatten<T> | RegExp)[]>
-  : (T | Flatten<T>);
-
-/** Represents a logical AND query. All sub-queries must be true. */
-export type ComparisonAndQuery<T = any> = {
-  $and: readonly ComparisonQueryOrValue<T>[],
-};
-
-/** Represents a logical OR query. At least one sub-query must be true. */
-export type ComparisonOrQuery<T = any> = {
-  $or: readonly ComparisonQueryOrValue<T>[],
-};
-
-/** Represents a NOT comparison query. Inverts the result of the nested comparison. */
-export type ComparisonNotQuery<T = any> = {
-  $not: ComparisonQueryOrValue<T>,
-};
-
-/** Represents an equality comparison query ($eq). */
-export type ComparisonEqualsQuery<T = any> = {
-  $eq: ComparisonValueWithRegex<T>,
-};
-
-/** Represents a non-equality comparison query ($neq). */
-export type ComparisonNotEqualsQuery<T = any> = {
-  $neq: ComparisonValueWithRegex<T>,
-};
-
-/** Represents an existence check query ($exists). Checks if a field exists (or not). */
-export type ComparisonExistsQuery = {
-  $exists: ComparisonValue<boolean>,
-};
-
-/** Represents a query targeting elements within an array field ($item). */
-export type ComparisonItemQuery<T = any> = {
-  $item: T extends readonly (infer U)[]
-  ? U extends Record
-  ? Query<U>
-  : ComparisonQuery<U>
-  : never,
-};
-
-/** Represents an "in list" comparison query ($in). Checks if a field value is within a specified array. */
-export type ComparisonInQuery<T = any> = {
-  $in: readonly ComparisonValueWithRegex<T>[],
-};
-
-/** Represents a "not in list" comparison query ($nin). Checks if a field value is not within a specified array. */
-export type ComparisonNotInQuery<T = any> = {
-  $nin: readonly ComparisonValueWithRegex<T>[],
-};
-
-/** Represents an "all elements match" query ($all). Checks if an array field contains all specified values. */
-export type ComparisonAllQuery<T = any> = {
-  $all: readonly ComparisonValueWithRegex<T>[],
-};
-
-/** Represents a "greater than" comparison query ($gt). */
-export type ComparisonGreaterThanQuery<T = any> = {
-  $gt: ComparisonValue<T>,
-};
-
-/** Represents a "greater than or equals" comparison query ($gte). */
-export type ComparisonGreaterThanOrEqualsQuery<T = any> = {
-  $gte: ComparisonValue<T>,
-};
-
-/** Represents a "less than" comparison query ($lt). */
-export type ComparisonLessThanQuery<T = any> = {
-  $lt: ComparisonValue<T>,
-};
-
-/** Represents a "less than or equals" comparison query ($lte). */
-export type ComparisonLessThanOrEqualsQuery<T = any> = {
-  $lte: ComparisonValue<T>,
-};
-
-/** Represents a regular expression comparison query ($regex). */
-export type ComparisonRegexQuery = {
-  $regex: string | RegExp | { pattern: string, flags: string },
-};
-
-/** Represents a single-field tsvector full-text search query. */
-export type ComparisonTsVectorQuery = {
-  $tsvector: string | {
-    query: string,
-    parser?: TsVectorParser,
-
-    /**
-     * The language to use for the full-text search (e.g., 'english', 'simple').
-     */
-    language?: string | SQL,
-  },
-};
-
-/** Represents a single-field trigram similarity search query. */
-export type ComparisonTrigramQuery = {
-  $trigram: string | {
-    query: string,
-    type?: TrigramSimilarityType,
-
-    /**
-     * ### **WARNING**
-     * Using a threshold here impacts performance as it switches from the `%` operator to a similarity comparison requiring functions.
-     * Use `pg_trgm.similarity_threshold(threshold)`, `pg_trgm.word_similarity_threshold(threshold)` or `pg_trgm.-_similarity_threshold(threshold)` to set a global threshold instead and omit this option, if possible.
-     */
-    threshold?: number,
-  },
-};
-
-/** Defines the possible spatial relationships for geospatial shape queries. */
-export type GeoShapeRelation = 'intersects' | 'within' | 'disjoint' | 'contains';
-
-/** Represents a geospatial query based on shape relationships ($geoShape). */
-export type ComparisonGeoShapeQuery = {
-  $geoShape: {
-    geometry: Geometry,
-    relation: GeoShapeRelation,
-  },
-};
-
-/** Represents a geospatial query based on distance from a point ($geoDistance). */
-export type ComparisonGeoDistanceQuery = {
-  $geoDistance: {
-    longitude: number,
-    latitude: number,
-
-    /**
-     * Maximum distance in meters
-     */
-    maxDistance?: number,
-
-    /**
-     * Minimum distance in meters
-     */
-    minDistance?: number,
-  },
-};
-
-/** Represents a multi-field tsvector search. */
-export type TsVectorSearchQuery<T extends BaseEntity = BaseEntity> = {
-  $tsvector: {
-    fields: readonly (TargetColumnPath<T> | readonly [TargetColumnPath<T>, TsVectorWeight])[],
-    query: string | SQL<string>,
-    parser?: TsVectorParser,
-    language?: string | SQL<string>,
-  },
-};
-
-/** Represents a multi-field trigram search. */
-export type TrigramSearchQuery<T extends BaseEntity = BaseEntity> = {
-  $trigram: {
-    fields: readonly TargetColumnPath<T>[],
-    query: string | SQL<string>,
-    type?: TrigramSimilarityType,
-    threshold?: number,
-  },
-};

package/source/orm/query/index.ts

@@ -1,2 +0,0 @@
-export * from './base.js';
-export * from './parade.js';

package/source/orm/query/parade.ts

@@ -1,135 +0,0 @@
-import type { SQL } from 'drizzle-orm';
-import type { LiteralUnion, UnionToIntersection } from 'type-fest';
-
-import type { Record } from '#/types/index.js';
-import type { BaseEntity } from '../entity.js';
-import type { TargetColumnPath } from '../repository.types.js';
-
-/** Represents a comparison query using various operators like $eq, $ne, $gt, $in, etc. */
-export type ParadeComparisonQuery = Partial<
-  & ComparisonParadeQuery
->;
-
-/** Union of keys representing comparison query operators. */
-export type ParadeComparisonQueryTypes = keyof ParadeComparisonQuery;
-
-/** Array containing all valid comparison query operator keys. */
-export const paradeComparisonQueryTypes: ParadeComparisonQueryTypes[] = ['$parade'];
-
-/** Represents specialized query types beyond simple comparisons. */
-export type ParadeSpecialQuery<T extends BaseEntity = BaseEntity> =
-  | ParadeSearchQuery<T>
-  | { $parade: ParadeSpecialQueryObject<T> };
-
-/** Union of keys representing special query operators. */
-export type ParadeSpecialQueryTypes = keyof UnionToIntersection<ParadeSpecialQuery>;
-
-/** Array containing all valid special query operator keys. */
-export const paradeSpecialQueryTypes: ParadeSpecialQueryTypes[] = ['$parade'];
-
-/** Represents a ParadeDB query on a specific field. */
-export type ComparisonParadeQuery = {
-  $parade: ParadeComparisonQueryObject,
-};
-
-/** Represents a term in a proximity query. */
-export type ParadeProximityTerm = string | { regex: string, maxExpansions?: number } | { array: readonly (string | { regex: string, maxExpansions?: number })[] };
-
-/**
- * Represents a bound for a ParadeDB range query.
- */
-type ParadeRangeBound<V> = { included: V } | { excluded: V };
-
-/** A recursive type representing the rich ParadeDB / Tantivy query DSL for FIELD-LEVEL queries. */
-export type ParadeComparisonQueryObject = {
-  term?: { value: any, boost?: number, const?: number },
-  fuzzyTerm?: { value: string, distance?: number, transpositionCostOne?: boolean, prefix?: boolean, boost?: number, const?: number },
-  regex?: { pattern: string, boost?: number, const?: number },
-  phrase?: { phrases: readonly string[], slop?: number, boost?: number, const?: number },
-  match?: { value: string, distance?: number, prefix?: boolean, conjunctionMode?: boolean, tokenizer?: ParadeTokenizerObject, transpositionCostOne?: boolean, boost?: number, const?: number },
-  exists?: null,
-  range?: { lowerBound?: ParadeRangeBound<any> | null, upperBound?: ParadeRangeBound<any> | null, isDatetime?: boolean },
-  termSet?: { terms: readonly string[], conjunctionMode?: boolean },
-  phrasePrefix?: { phrases: readonly string[], maxExpansions?: number },
-  regexPhrase?: { regexes: readonly string[], slop?: number, maxExpansions?: number },
-  rangeTerm?: { value: any, operator?: 'Intersects' | 'Contains' | 'Within' },
-  proximity?: {
-    ordered?: boolean,
-    distance: number,
-    terms: readonly [ParadeProximityTerm, ParadeProximityTerm, ...ParadeProximityTerm[]],
-  },
-};
-
-/**
- * A type representing the rich ParadeDB / Tantivy query DSL for TOP-LEVEL queries.
- */
-export type ParadeSpecialQueryObject<T extends BaseEntity = BaseEntity> = {
-  all?: null,
-  empty?: null,
-  moreLikeThis?: {
-    keyValue?: any,
-    document?: Record<TargetColumnPath<T>>,
-    fields?: readonly TargetColumnPath<T>[],
-    minDocFrequency?: number,
-    maxDocFrequency?: number,
-    minTermFrequency?: number,
-    maxQueryTerms?: number,
-    minWordLength?: number,
-    maxWordLength?: number,
-    stopWords?: readonly string[],
-  },
-};
-
-/**
- * Represents a ParadeDB search using its native JSON-based query language,
- * or a simplified multi-field match query.
- */
-export type ParadeSearchQuery<T extends BaseEntity = BaseEntity> = {
-  $parade: {
-    /** The fields to search across. */
-    fields: readonly [TargetColumnPath<T>, ...TargetColumnPath<T>[]],
-
-    /** The search query string. */
-    query: string | SQL<string>,
-
-    /**
-     * The conjunction mode for token matching within the query string.
-     * `true` for AND (all terms must match), `false` for OR (any term can match).
-     * Defaults to `false` (OR).
-     */
-    conjunction?: boolean,
-
-    /**
-     * If greater than zero, enables fuzzy matching.
-     * Specifies the maximum Levenshtein distance (edit distance). Max value is 2.
-     * @default 0
-     */
-    distance?: number,
-
-    /**
-     * When `true` and fuzzy matching is enabled, considers transpositions as a single edit.
-     * @default true
-     */
-    transpositionCostOne?: boolean,
-
-    /**
-     * When `true` and fuzzy matching is enabled, allows prefix matching.
-     * @default false
-     */
-    prefix?: boolean,
-
-    /**
-     * The alias of a field configuration to use for the search.
-     * If specified, all fields must have this alias defined.
-     */
-    alias?: string,
-  },
-};
-
-/**
- * Represents a ParadeDB tokenizer configuration object for a `match` query.
- */
-export type ParadeTokenizerObject = {
-  type: LiteralUnion<'default' | 'whitespace' | 'raw' | 'keyword' | 'regex' | 'ngram' | 'source_code' | 'chinese_compatible' | 'chinese_lindera' | 'korean_lindera' | 'japanese_lindera' | 'jieba' | 'icu', string>,
-  [key: string]: any,
-};

package/source/orm/repository.types.ts

@@ -1,221 +0,0 @@
-/**
- * @module
- * Defines types used by ORM repositories for operations like loading, updating, and creating entities.
- * Includes types for ordering, loading options, and entity data structures for create/update operations.
- */
-import type { Path, Record, SimplifyObject, TypedOmit } from '#/types/index.js';
-import type { UntaggedDeep } from '#/types/tagged.js';
-import type { AnyColumn, SQL, SQLWrapper } from 'drizzle-orm';
-import type { PartialDeep } from 'type-fest';
-import type { BaseEntity, Entity, EntityMetadata } from './entity.js';
-import type { FullTextSearchQuery, Query } from './query/index.js';
-import type { TsHeadlineOptions } from './sqls.js';
-
-type WithSql<T> = { [P in keyof T]: T[P] extends Record ? WithSql<T[P]> : (T[P] | SQL) };
-
-/**
- * Specifies the target column (e.g. for ordering, distinct on), which can be a property path within the entity
- * or a raw Drizzle SQLWrapper for a complex target.
- * @template T - The entity type.
- */
-export type TargetColumnPath<T extends BaseEntity = BaseEntity> = Path<UntaggedDeep<T>>;
-
-/**
- * Specifies the target column (e.g. for ordering, distinct on), which can be a property path within the entity
- * or a raw Drizzle SQLWrapper for a complex target.
- * @template T - The entity type.
- */
-export type TargetColumn<T extends BaseEntity = BaseEntity> = TargetColumnPath<T> | SQL | SQL.Aliased | AnyColumn;
-
-/** Specifies the direction for ordering results ('asc' or 'desc'). */
-export type OrderDirection = 'asc' | 'desc';
-
-/**
- * Defines how results should be ordered. Can be a single target, an array of targets
- * (optionally with direction), or an object mapping property paths to directions.
- * @template T - The entity type.
- */
-export type Order<T extends BaseEntity> = TargetColumn<T> | (TargetColumn<T> | [TargetColumn<T>, OrderDirection])[] | Partial<Record<Exclude<TargetColumn<T>, SQLWrapper>, OrderDirection>>;
-
-/**
- * Options object containing ordering configuration.
- * @template T - The entity type.
- */
-export type OrderOptions<T extends BaseEntity> = { order?: Order<T> };
-
-/**
- * Options for loading a single entity, including ordering and offset.
- * @template T - The entity type.
- */
-export type LoadOptions<T extends BaseEntity> = OrderOptions<T> & { offset?: number };
-/**
- * Options for loading multiple entities, including ordering, offset, and limit.
- * @template T - The entity type.
- */
-export type LoadManyOptions<T extends BaseEntity> = LoadOptions<T> & { limit?: number, distinct?: boolean | TargetColumn<T>[] };
-
-/**
- * Options for ranking search results.
- */
-export type RankOptions = {
-  /**
-   * Array of four numbers to weight D, C, B, and A labels respectively.
-   * Defaults to PostgreSQL's default {0.1, 0.2, 0.4, 1.0}.
-   */
-  weights?: [number, number, number, number],
-
-  /**
-   * Specifies how a document's length should impact its rank.
-   * It's a bitmask, e.g., 0 (default) ignores length, 2 divides by document length.
-   * See PostgreSQL documentation for `ts_rank_cd` for more details.
-   */
-  normalization?: number,
-};
-
-/**
- * Options for highlighting search results.
- */
-export type HighlightOptions<T extends BaseEntity> = {
-  /**
-   * The source to generate the highlight from. Can be one or more property paths or a raw SQL expression.
-   */
-  source: TargetColumnPath<T> | SQL<string>,
-
-  /**
-   * If true, includes the byte offsets of highlight matches in the result.
-   * @default false
-   */
-  includePositions?: boolean,
-} & (TsHeadlineOptions | ParadeDbHighlightOptions);
-
-/**
- * Options for highlighting with ParadeDB (`pdb.snippet` or `pdb.snippets`).
- */
-export type ParadeDbHighlightOptions = {
-  /**
-   * If true, retrieves multiple snippets using `pdb.snippets`.
-   * If false (default), retrieves a single best snippet using `pdb.snippet`.
-   */
-  multiple?: boolean,
-
-  /**
-   * Limits the number of characters in each snippet. Defaults to 150.
-   */
-  maxNumChars?: number,
-
-  /**
-   * The tag to use for the start of a highlighted term. Defaults to '<b>'.
-   */
-  startTag?: string,
-
-  /**
-   * The tag to use for the end of a highlighted term. Defaults to '</b>'.
-   */
-  endTag?: string,
-
-  /**
-   * The maximum number of snippets to return per document. Only used when `multiple` is true.
-   * @default 5
-   */
-  limit?: number;
-
-  /**
-   * The number of snippets to skip before returning results. Only used when `multiple` is true.
-   * @default 0
-   */
-  offset?: number;
-
-  /**
-   * The order in which to sort the snippets. Can be 'score' (default) or 'position'. Only used when `multiple` is true.
-   */
-  sortBy?: 'score' | 'position';
-};
-
-/**
- * Options for the `search` method.
- * @template T - The entity type.
- */
-export type SearchOptions<T extends BaseEntity> = SimplifyObject<TypedOmit<LoadManyOptions<T>, 'order'> & {
-  /**
-   * The search query to execute.
-   */
-  query: FullTextSearchQuery<T>,
-
-  /**
-   * An additional filter to apply to the search query.
-   */
-  filter?: Query<T>,
-
-  /**
-   * How to order the search results.
-   */
-  order?: Order<T> | ((columns: { score: SQL | SQL.Aliased<number> }) => Order<T>),
-
-  /**
-   * Whether to include a relevance score with each result.
-   * - If `true`, the default score is included.
-   * - If a function is provided, it customizes the score calculation using the original score.
-   * - If no order is specified, results are ordered by score descending, when score is enabled.
-   * @default true
-   */
-  score?: boolean | ((originalScore: SQL<number>) => SQL<number>),
-
-  /**
-   * Enable and configure ranking of search results.
-   * - If `true` (default), results are ordered by score descending using default ranking options.
-   * - If an `RankOptions` object is provided, ranking is customized.
-   * @default true
-   */
-  rank?: boolean | RankOptions,
-
-  /**
-   * Enable and configure highlighting of search results.
-   */
-  highlight?: TargetColumnPath<T> | SQL<string> | HighlightOptions<T>,
-}>;
-
-/**
- * Represents a single result from a full-text search operation.
- * @template T - The entity type.
- */
-export type SearchResult<T extends BaseEntity> = {
-  entity: T,
-  score?: number,
-  highlight?: string | string[],
-  /**
-   * Byte offsets of highlight matches. Format is an array of start/end pairs.
-   * e.g., `[{ start: 14, end: 19 }]`
-   */
-  highlightPositions?: [start: number, end: number][],
-};
-
-/**
- * Options for update operations (currently inherits from LoadOptions, primarily for ordering).
- * @template T - The entity type.
- */
-export type UpdateOptions<T extends BaseEntity> = LoadOptions<T>;
-
-/** Type definition for updating entity metadata attributes, allowing partial updates and SQL expressions. */
-export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes'>>>>;
-
-export type EntityMetadataInsert = Partial<Pick<EntityMetadata, 'attributes'>>;
-
-/**
- * Represents the data structure for creating a new entity.
- * Excludes 'id' and 'metadata' by default, but allows providing an optional 'id' and partial 'metadata.attributes'.
- * Allows SQL expressions for values.
- * @template T - The entity type.
- */
-export type NewEntity<T extends Entity | BaseEntity> = T extends Entity
-  ? WithSql<UntaggedDeep<TypedOmit<T, 'id' | 'metadata'> & { id?: string, metadata?: EntityMetadataInsert }>>
-  : WithSql<UntaggedDeep<TypedOmit<T, 'id'> & { id?: string }>>;
-
-/**
- * Represents the data structure for updating an existing entity.
- * Allows partial updates for all properties (using PartialDeep) and specific updates for 'metadata.attributes'.
- * Allows SQL expressions for values.
- * @template T - The entity type.
- */
-export type EntityUpdate<T extends BaseEntity> = T extends Entity
-  ? WithSql<PartialDeep<UntaggedDeep<TypedOmit<T, 'metadata'>>>> & { metadata?: EntityMetadataUpdate }
-  : WithSql<PartialDeep<UntaggedDeep<T>>>;

package/source/orm/schemas/index.ts

@@ -1,6 +0,0 @@
-export * from './json.js';
-export * from './numeric-date.js';
-export * from './numeric.js';
-export * from './timestamp.js';
-export * from './tsvector.js';
-export * from './uuid.js';

package/source/orm/schemas/json.ts

@@ -1,38 +0,0 @@
-import type { JsonPath } from '#/json-path/json-path.js';
-import { createDecorator, type Decorator, type PropertyMetadata } from '#/reflection/index.js';
-import { any, Class, object, Property, Schema, type SchemaDecoratorOptions, type SchemaTestable, schemaTestableToSchema, type SchemaTestOptions, type SchemaTestResult } from '#/schema/index.js';
-import type { Constructor, TypedOmit } from '#/types/index.js';
-import { isDefined } from '#/utils/type-guards.js';
-
-export type JsonSchemaOptions<T> = { schema?: SchemaTestable<T> };
-
-export class JsonSchema<T> extends Schema<T> {
-  readonly name = 'Json';
-  readonly innerSchema: Schema<T>;
-
-  constructor(options?: JsonSchemaOptions<T>) {
-    super();
-
-    this.innerSchema = isDefined(options?.schema) ? schemaTestableToSchema(options.schema) : any();
-  }
-
-  override _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T> {
-    return this.innerSchema._test(value, path, options);
-  }
-}
-
-export function json<T>(options?: JsonSchemaOptions<T>): JsonSchema<T> {
-  return new JsonSchema(options);
-}
-
-export function JsonProperty(options?: JsonSchemaOptions<any> & TypedOmit<SchemaDecoratorOptions, 'schema'>): Decorator<'class' | 'property' | 'accessor'> {
-  const { schema, ...optionsRest } = options ?? {};
-
-  return createDecorator({ class: true, property: true, accessor: true }, (data, metadata, args) => {
-    if (data.type == 'class') {
-      return Class({ schema: json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: { type: data.constructor as Constructor } }) }) })(args[0] as Constructor);
-    }
-
-    return Property(json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: { type: (metadata as PropertyMetadata).type as Constructor } }) }), optionsRest)(args[0], args[1]!, args[2]!);
-  });
-}