@uql/core 1.0.12 → 3.0.0

package/dist/test/entityMock.js

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

package/dist/test/index.d.ts

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

package/dist/test/index.js

@@ -0,0 +1,4 @@
+export * from './entityMock.js';
+export * from './it.util.js';
+export * from './spec.util.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VudGl0eU1vY2suanMnO1xuZXhwb3J0ICogZnJvbSAnLi9pdC51dGlsLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3BlYy51dGlsLmpzJztcbiJdfQ==

package/dist/test/it.util.d.ts

@@ -0,0 +1,4 @@
+import type { AbstractSqlQuerier } from '../querier/index.js';
+export declare function createTables(querier: AbstractSqlQuerier, primaryKeyType: string): Promise<void>;
+export declare function dropTables(querier: AbstractSqlQuerier): Promise<void>;
+export declare function clearTables(querier: AbstractSqlQuerier): Promise<void>;

package/dist/test/it.util.js

@@ -0,0 +1,55 @@
+import { getEntities, getMeta } from '../entity/decorator/index.js';
+import { getKeys } from '../util/index.js';
+export async function createTables(querier, primaryKeyType) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity) => {
+        const sql = getDdlForTable(entity, querier, primaryKeyType);
+        return querier.run(sql);
+    }));
+}
+export async function dropTables(querier) {
+    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) {
+    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(entity, querier, primaryKeyType) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,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