@uql/core 3.1.0 → 3.1.2

package/src/test/entityMock.ts

@@ -1,375 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { Entity, Field, Id, ManyToMany, ManyToOne, OneToMany, OneToOne } from '../entity/index.js';
-import { idKey, type Relation } from '../type/index.js';
-import { raw } from '../util/index.js';
-
-/**
- * an `abstract` class can (optionally) be used as the base "template" for the entities
- * (so common fields' declaration is easily reused).
- */
-export abstract class BaseEntity {
-  /**
-   * auto-generated primary-key (when the `onInsert` property is omitted).
-   */
-  @Id()
-  id?: number;
-
-  /**
-   * foreign-keys are really simple to specify with the `reference` property.
-   */
-  @Field({ reference: () => Company })
-  companyId?: number;
-
-  /**
-   * The `Relation` wrapper type can be used in ESM projects for the relations to
-   * avoid circular dependency issues.
-   */
-  @ManyToOne({ entity: () => Company })
-  company?: Relation<Company>;
-
-  @Field({ reference: () => User })
-  creatorId?: number;
-
-  @ManyToOne({ entity: () => User })
-  creator?: Relation<User>;
-
-  /**
-   * 'onInsert' property can be used to specify a custom mechanism for
-   * obtaining the value of a field when inserting:
-   */
-  @Field({ onInsert: Date.now })
-  createdAt?: number;
-
-  /**
-   * 'onUpdate' property can be used to specify a custom mechanism for
-   * obtaining the value of a field when updating:
-   */
-  @Field({ onUpdate: Date.now })
-  updatedAt?: number;
-}
-
-export type CompanyKindKey = 'public' | 'private';
-
-export type CompanyKind = { [k in CompanyKindKey]?: 0 | 1 };
-
-/**
- * `Company` will inherit all the fields (including the `Id`) declared in `BaseEntity`.
- */
-@Entity()
-export class Company extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field()
-  description?: string;
-
-  @Field({ type: 'jsonb' })
-  kind?: CompanyKind;
-}
-
-/**
- * and entity can specify the table name.
- */
-@Entity({ name: 'user_profile' })
-export class Profile extends BaseEntity {
-  /**
-   * an entity can specify its own ID Field and still inherit the others
-   * columns/relations from its parent entity.
-   */
-  @Id()
-  pk?: number;
-
-  @Field({ name: 'image' })
-  picture?: string;
-
-  @OneToOne({ entity: () => User })
-  declare creator?: Relation<User>;
-}
-
-@Entity()
-export class User extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field({ updatable: false })
-  email?: string;
-
-  @Field({ eager: false })
-  password?: string;
-
-  /**
-   * `mappedBy` property can be a callback or a string (callback is useful for auto-refactoring).
-   */
-  @OneToOne({ entity: () => Profile, mappedBy: (profile) => profile.creator, cascade: true })
-  profile?: Profile;
-
-  @OneToMany({ entity: () => User, mappedBy: 'creator' })
-  users?: User[];
-}
-
-@Entity()
-export class UserWithNonUpdatableId {
-  @Id({ updatable: false })
-  id: number;
-
-  @Field()
-  name: string;
-}
-
-@Entity()
-export class LedgerAccount extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field()
-  description?: string;
-
-  @Field({ reference: () => LedgerAccount })
-  parentLedgerId?: number;
-
-  @ManyToOne()
-  parentLedger?: LedgerAccount;
-}
-
-@Entity()
-export class TaxCategory extends BaseEntity {
-  /**
-   * `idKey` symbol can be used to specify the name of the identifier property,
-   * so the type of the identifier can always be type-safe
-   * (the identifiers named as `id` or `_id` are auto-inferred).
-   */
-  [idKey]?: 'pk';
-
-  /**
-   * an entity can override the ID Field and still inherit the others
-   * columns/relations from its parent entity.
-   * 'onInsert' property can be used to specify a custom mechanism for
-   * auto-generating the primary-key's value when inserting.
-   */
-  @Id({ onInsert: randomUUID })
-  pk?: string;
-
-  @Field()
-  name?: string;
-
-  @Field()
-  description?: string;
-}
-
-@Entity()
-export class Tax extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field()
-  percentage?: number;
-
-  @Field({ reference: () => TaxCategory })
-  categoryId?: string;
-
-  @ManyToOne()
-  category?: TaxCategory;
-
-  @Field()
-  description?: string;
-}
-
-/**
- * `softDelete` will make the entity "soft deletable".
- */
-@Entity({ softDelete: true })
-export class MeasureUnitCategory extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @OneToMany({ entity: () => MeasureUnit, mappedBy: (measureUnit) => measureUnit.categoryId })
-  measureUnits?: MeasureUnit[];
-
-  /**
-   * `onDelete` callback allows to specify which field will be used when deleting/querying this entity.
-   */
-  @Field({ onDelete: Date.now })
-  deletedAt?: number;
-}
-
-@Entity({ softDelete: true })
-export class MeasureUnit extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field({ reference: () => MeasureUnitCategory })
-  categoryId?: number;
-
-  @ManyToOne({ cascade: 'persist' })
-  category?: MeasureUnitCategory;
-
-  @Field({ onDelete: Date.now })
-  deletedAt?: number;
-}
-
-@Entity()
-export class Storehouse extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field()
-  address?: string;
-
-  @Field()
-  description?: string;
-}
-
-@Entity()
-export class Item extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @Field()
-  description?: string;
-
-  @Field()
-  code?: string;
-
-  @Field({ reference: () => LedgerAccount })
-  buyLedgerAccountId?: number;
-
-  @ManyToOne()
-  buyLedgerAccount?: LedgerAccount;
-
-  @Field({ reference: () => LedgerAccount })
-  saleLedgerAccountId?: number;
-
-  @ManyToOne()
-  saleLedgerAccount?: LedgerAccount;
-
-  @Field({ reference: () => Tax })
-  taxId?: number;
-
-  @ManyToOne()
-  tax?: Tax;
-
-  @Field({ reference: () => MeasureUnit })
-  measureUnitId?: number;
-
-  @ManyToOne()
-  measureUnit?: MeasureUnit;
-
-  @Field()
-  salePrice?: number;
-
-  @Field()
-  inventoryable?: boolean;
-
-  @ManyToMany({ entity: () => Tag, through: () => ItemTag, cascade: true })
-  tags?: Tag[];
-
-  @Field({
-    /**
-     * `virtual` property allows defining the value for a non-persistent field,
-     * such value might be a scalar or a (`raw`) function. Virtual-fields can
-     * be used in `$select` and `$where` as a common field whose value is
-     * replaced is replaced at runtime.
-     */
-    virtual: raw(({ ctx, escapedPrefix, dialect }) => {
-      ctx.append('(');
-      dialect.count(
-        ctx,
-        ItemTag,
-        {
-          $where: {
-            itemId: raw(({ ctx }) => {
-              ctx.append(escapedPrefix + dialect.escapeId('id'));
-            }),
-          },
-        },
-        { autoPrefix: true },
-      );
-      ctx.append(')');
-    }),
-  })
-  tagsCount?: number;
-}
-
-@Entity()
-export class Tag extends BaseEntity {
-  @Field()
-  name?: string;
-
-  @ManyToMany({ entity: () => Item, mappedBy: (item) => item.tags })
-  items?: Item[];
-
-  @Field({
-    virtual: raw(({ ctx, escapedPrefix, dialect }) => {
-      ctx.append('(');
-      dialect.count(
-        ctx,
-        ItemTag,
-        {
-          $where: {
-            tagId: raw(({ ctx }) => {
-              ctx.append(escapedPrefix + dialect.escapeId('id'));
-            }),
-          },
-        },
-        { autoPrefix: true },
-      );
-      ctx.append(')');
-    }),
-  })
-  itemsCount?: number;
-}
-
-@Entity()
-export class ItemTag {
-  @Id()
-  id?: number;
-
-  @Field({ reference: () => Item })
-  itemId?: number;
-
-  @Field({ reference: () => Tag })
-  tagId?: number;
-}
-
-@Entity()
-export class InventoryAdjustment extends BaseEntity {
-  @OneToMany({
-    entity: () => ItemAdjustment,
-    mappedBy: (rel) => rel.inventoryAdjustment,
-    cascade: true,
-  })
-  itemAdjustments?: ItemAdjustment[];
-
-  @Field()
-  date?: Date;
-
-  @Field()
-  description?: string;
-}
-
-@Entity()
-export class ItemAdjustment extends BaseEntity {
-  @Field({ reference: () => Item })
-  itemId?: number;
-
-  @ManyToOne()
-  item?: Item;
-
-  @Field()
-  number?: number;
-
-  @Field()
-  buyPrice?: number;
-
-  @Field({ reference: () => Storehouse })
-  storehouseId?: number;
-
-  @ManyToOne()
-  storehouse?: Storehouse;
-
-  @Field({ reference: () => InventoryAdjustment })
-  inventoryAdjustmentId?: number;
-
-  @ManyToOne()
-  inventoryAdjustment?: InventoryAdjustment;
-}

package/src/test/index.ts

@@ -1,3 +0,0 @@
-export * from './entityMock.js';
-export * from './it.util.js';
-export * from './spec.util.js';

package/src/test/it.util.ts

@@ -1,69 +0,0 @@
-import { getEntities, getMeta } from '../entity/decorator/index.js';
-import type { AbstractSqlQuerier } from '../querier/index.js';
-import type { Type } from '../type/index.js';
-import { getKeys } from '../util/index.js';
-
-export async function createTables(querier: AbstractSqlQuerier, primaryKeyType: string) {
-  const entities = getEntities();
-  await Promise.all(
-    entities.map((entity) => {
-      const sql = getDdlForTable(entity, querier, primaryKeyType);
-      return querier.run(sql);
-    }),
-  );
-}
-
-export async function dropTables(querier: AbstractSqlQuerier) {
-  const entities = getEntities();
-  await Promise.all(
-    entities.map((entity) => {
-      const meta = getMeta(entity);
-      const sql = `DROP TABLE IF EXISTS ${querier.dialect.escapeId(meta.name)}`;
-      return querier.run(sql);
-    }),
-  );
-}
-
-export async function clearTables(querier: AbstractSqlQuerier) {
-  const entities = getEntities();
-  await Promise.all(
-    entities.map((entity) => {
-      const ctx = querier.dialect.createContext();
-      querier.dialect.delete(ctx, entity, {});
-      return querier.run(ctx.sql, ctx.values);
-    }),
-  );
-}
-
-function getDdlForTable<E>(entity: Type<E>, querier: AbstractSqlQuerier, primaryKeyType: string) {
-  const meta = getMeta(entity);
-
-  let sql = `CREATE TABLE ${querier.dialect.escapeId(meta.name)} (\n\t`;
-
-  const insertableIdType = 'VARCHAR(36)';
-  const defaultType = 'VARCHAR(255)';
-
-  const columns = getKeys(meta.fields).map((key) => {
-    const field = meta.fields[key];
-    let propSql = querier.dialect.escapeId(field.name) + ' ';
-    if (field.isId) {
-      propSql += field.onInsert ? `${insertableIdType} PRIMARY KEY` : primaryKeyType;
-    } else {
-      if (field.type === Number) {
-        propSql += 'BIGINT';
-      } else if (field.type === Date) {
-        propSql += 'TIMESTAMP';
-      } else {
-        propSql += defaultType;
-      }
-    }
-    return propSql;
-  });
-
-  sql += columns.join(',\n\t');
-  sql += `\n);`;
-
-  // log('sql', sql);
-
-  return sql;
-}

package/src/test/spec.util.ts

@@ -1,57 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, it } from 'bun:test';
-
-export function createSpec<T extends Spec>(spec: T) {
-  const proto: FunctionConstructor = Object.getPrototypeOf(spec);
-  let describeFn: typeof describe;
-  const specName = proto.constructor.name;
-
-  if (specName.startsWith('fff')) {
-    describeFn = describe.only;
-  } else if (specName.startsWith('xxx')) {
-    describeFn = describe.skip;
-  } else {
-    describeFn = describe;
-  }
-
-  describeFn(specName, () => createTestCases(spec));
-}
-
-function createTestCases(spec: object) {
-  let proto: FunctionConstructor = Object.getPrototypeOf(spec);
-
-  const processedMethodsMap: { [k: string]: true } = {};
-
-  while (proto.constructor !== Object) {
-    for (const key of Object.getOwnPropertyNames(proto)) {
-      const isProcessed = processedMethodsMap[key];
-      processedMethodsMap[key] = true;
-      if (isProcessed || key === 'constructor' || typeof spec[key] !== 'function') {
-        continue;
-      }
-      const callback: () => void | Promise<void> = spec[key].bind(spec);
-      if (hooks[key]) {
-        hooks[key](callback);
-      } else if (key.startsWith('should')) {
-        it(key, callback);
-      } else if (key.startsWith('fffShould')) {
-        it.only(key, callback);
-      } else if (key.startsWith('xxxShould')) {
-        it.skip(key, callback);
-      }
-    }
-    proto = Object.getPrototypeOf(proto);
-  }
-}
-
-const hooks = {
-  beforeAll,
-  beforeEach,
-  afterEach,
-  afterAll,
-} as const;
-
-type SpecHooks = Partial<typeof hooks>;
-
-export type Spec = SpecHooks & {
-  readonly [k: string]: (() => void | Promise<void>) | any;
-};

package/src/type/entity.ts

@@ -1,218 +0,0 @@
-import type { QueryRaw } from './query.js';
-import type { Scalar, Type } from './utility.js';
-
-/**
- * Allow to customize the name of the property that identifies an entity
- */
-export const idKey = Symbol('idKey');
-
-/**
- * Infers the key names of an entity
- */
-export type Key<E> = keyof E & string;
-
-/**
- * Infers the field names of an entity
- */
-export type FieldKey<E> = {
-  readonly [K in keyof E]: E[K] extends Scalar ? K : never;
-}[Key<E>];
-
-/**
- * Infers the relation names of an entity
- */
-export type RelationKey<E> = {
-  readonly [K in keyof E]: E[K] extends Scalar ? never : K;
-}[Key<E>];
-
-/**
- * Infers the field values of an entity
- */
-export type FieldValue<E> = E[FieldKey<E>];
-
-/**
- * Infers the name of the key identifier on an entity
- */
-export type IdKey<E> = E extends { [idKey]?: infer K }
-  ? K & FieldKey<E>
-  : E extends { _id?: unknown }
-    ? '_id' & FieldKey<E>
-    : E extends { id?: unknown }
-      ? 'id' & FieldKey<E>
-      : E extends { uuid?: unknown }
-        ? 'uuid' & FieldKey<E>
-        : FieldKey<E>;
-
-/**
- * Infers the value of the key identifier on an entity
- */
-export type IdValue<E> = E[IdKey<E>];
-
-/**
- * Infers the values of the relations on an entity
- */
-export type RelationValue<E> = E[RelationKey<E>];
-
-/**
- * Configurable options for an entity
- */
-export type EntityOptions = {
-  readonly name?: string;
-  readonly softDelete?: boolean;
-};
-
-/**
- * SQL column types supported by uql migrations
- */
-export type ColumnType =
-  | 'int'
-  | 'smallint'
-  | 'bigint'
-  | 'float'
-  | 'double'
-  | 'decimal'
-  | 'numeric'
-  | 'real'
-  | 'boolean'
-  | 'char'
-  | 'varchar'
-  | 'text'
-  | 'uuid'
-  | 'date'
-  | 'time'
-  | 'timestamp'
-  | 'timestamptz'
-  | 'json'
-  | 'jsonb'
-  | 'blob'
-  | 'bytea'
-  | 'vector'
-  | 'serial'
-  | 'bigserial';
-
-/**
- * Configurable options for a field
- */
-export type FieldOptions = {
-  readonly name?: string;
-  readonly isId?: true;
-  readonly type?: any;
-  readonly reference?: EntityGetter;
-  readonly virtual?: QueryRaw;
-  readonly updatable?: boolean;
-  readonly eager?: boolean;
-  readonly onInsert?: OnFieldCallback;
-  readonly onUpdate?: OnFieldCallback;
-  readonly onDelete?: OnFieldCallback;
-
-  // Schema/migration properties
-  /**
-   * SQL column type for migrations. If not specified, inferred from TypeScript type.
-   */
-  readonly columnType?: ColumnType;
-  /**
-   * Column length (e.g., VARCHAR(100)). Defaults to 255 for varchar.
-   */
-  readonly length?: number;
-  /**
-   * Precision for decimal/numeric types.
-   */
-  readonly precision?: number;
-  /**
-   * Scale for decimal/numeric types.
-   */
-  readonly scale?: number;
-  /**
-   * Whether the column allows NULL values. Defaults to true except for ID fields.
-   */
-  readonly nullable?: boolean;
-  /**
-   * Whether the column has a UNIQUE constraint.
-   */
-  readonly unique?: boolean;
-  /**
-   * Default value for the column.
-   */
-  readonly defaultValue?: Scalar | null;
-  /**
-   * Whether the column is auto-incrementing (for integer IDs).
-   */
-  readonly autoIncrement?: boolean;
-  /**
-   * Index configuration. true for simple index, string for named index.
-   */
-  readonly index?: boolean | string;
-  /**
-   * Column comment/description for database documentation.
-   */
-  readonly comment?: string;
-};
-
-export type OnFieldCallback = Scalar | QueryRaw | (() => Scalar | QueryRaw);
-
-export type EntityGetter<E = any> = () => Type<E>;
-
-export type CascadeType = 'persist' | 'delete';
-
-export type RelationOptions<E = any> = {
-  entity?: EntityGetter<E>;
-  cardinality: RelationCardinality;
-  readonly cascade?: boolean | CascadeType;
-  mappedBy?: RelationMappedBy<E>;
-  through?: EntityGetter<RelationValue<E>>;
-  references?: RelationReferences;
-};
-type RelationOptionsOwner<E> = Pick<RelationOptions<E>, 'entity' | 'references' | 'cascade'>;
-type RelationOptionsInverseSide<E> = Required<Pick<RelationOptions<E>, 'entity' | 'mappedBy'>> &
-  Pick<RelationOptions<E>, 'cascade'>;
-type RelationOptionsThroughOwner<E> = Required<Pick<RelationOptions<E>, 'entity'>> &
-  Pick<RelationOptions<E>, 'through' | 'references' | 'cascade'>;
-
-export type RelationKeyMap<E> = { readonly [K in keyof E]: K };
-
-export type RelationKeyMapper<E> = (keyMap: RelationKeyMap<E>) => Key<E>;
-
-export type RelationReferences = { readonly local: string; readonly foreign: string }[];
-
-export type RelationMappedBy<E> = Key<E> | RelationKeyMapper<E>;
-
-export type RelationCardinality = '11' | 'm1' | '1m' | 'mm';
-
-export type RelationOneToOneOptions<E> = RelationOptionsOwner<E> | RelationOptionsInverseSide<E>;
-
-export type RelationOneToManyOptions<E> = RelationOptionsInverseSide<E> | RelationOptionsThroughOwner<E>;
-
-export type RelationManyToOneOptions<E> = RelationOptionsOwner<E>;
-
-export type RelationManyToManyOptions<E> = RelationOptionsThroughOwner<E> | RelationOptionsInverseSide<E>;
-
-/**
- * Wrapper type for relation type definitions in entities.
- * Used to circumvent ESM modules circular dependency issue caused by reflection metadata saving the type of the property.
- *
- * Usage example:
- * @Entity()
- * export default class User {
- *
- *     @OneToOne(() => Profile, profile => profile.user)
- *     profile: Relation<Profile>;
- *
- * }
- */
-export type Relation<T> = T;
-
-export type EntityMeta<E> = {
-  readonly entity: Type<E>;
-  name?: string;
-  id?: IdKey<E>;
-  softDelete?: FieldKey<E>;
-  fields: {
-    [K in FieldKey<E>]?: FieldOptions;
-  };
-  relations: {
-    [K in RelationKey<E>]?: RelationOptions;
-  };
-  processed?: boolean;
-};
-
-export type Primitive = string | number | symbol;