proflores-db-model 0.1.34 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proflores-db-model",
-  "version": "0.1.34",
+  "version": "0.2.1",
   "description": "Data model for managing expenses and transactions for Proflores nursery business",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,12 +11,12 @@
     "prepublishOnly": "yarn build"
   },
   "dependencies": {
-    "reflect-metadata": "^0.1.13",
-    "typeorm": "^0.2.45"
+    "reflect-metadata": "^0.2.2",
+    "typeorm": "^0.3.22"
   },
   "devDependencies": {
-    "@types/node": "^22.8.7",
+    "@types/node": "^22.15.3",
     "ts-node": "^10.0.0",
-    "typescript": "^4.0.0"
+    "typescript": "^5.8.3"
   }
 }

package/src/entities/Inventory.ts

@@ -14,6 +14,7 @@ import { ContainerType } from "./ContainerType";
 import { Supplier } from "./Suppliers";
 import { InventoryImage } from "./InventoryImage";
 import { InventoryMovement } from "./InventoryMovement";
+
 @Entity("inventory")
 export class Inventory implements ObjectLiteral {
   @PrimaryGeneratedColumn("increment")

package/src/index.ts

@@ -21,3 +21,4 @@ export { SupplierImage } from "./entities/SupplierImage";
 export { InventoryImage } from "./entities/InventoryImage";
 
 export * from "./types";
+export * from "./models/technical-sheet";

package/src/models/technical-sheet/CareInstructions.ts

@@ -0,0 +1,45 @@
+// src/models/technical-sheet/entities/CareInstructions.ts
+
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    ObjectLiteral,
+    OneToOne,
+    JoinColumn,
+  } from 'typeorm';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  
+  @Entity('care_instructions')
+  export class CareInstructions implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idCareInstructions!: number;
+  
+    @Column('text')
+    light!: string;
+  
+    @Column('text')
+    watering!: string;
+  
+    @Column('text')
+    humidity!: string;
+  
+    @Column('text')
+    temperature!: string;
+  
+    @Column('text')
+    substrate!: string;
+  
+    @Column('text')
+    fertilization!: string;
+  
+    @Column('text')
+    pruning!: string;
+  
+    @Column('text', { nullable: true })
+    notes?: string;
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/ClimateIdeal.ts

@@ -0,0 +1,32 @@
+import {
+    Column,
+    Entity,
+    PrimaryGeneratedColumn,
+    OneToMany,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { CLIMATE, ClimateType } from './catalogs/climate-ideal';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('climate_ideal')
+  export class ClimateIdeal implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idClimateIdeal!: number;
+  
+    @EnumColumn(Object.keys(CLIMATE) as ClimateType[])
+    type!: ClimateType;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    @Column('simple-json', { nullable: true })
+    temperatureRangeC?: [number, number];
+  
+    @OneToMany(() => ImageInfo, (image) => image.climateIdeal)
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/FertilizationInfo.ts

@@ -0,0 +1,50 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  OneToMany,
+  ObjectLiteral,
+} from "typeorm";
+import {
+  FERTILIZER_TYPE,
+  FERTILIZER_FREQ,
+  FERTILIZER_METHOD,
+  FertilizerType,
+  FertilizerFrequency,
+  FertilizerMethod,
+} from "./catalogs/fertilization-info";
+import { PlantTechnicalSheet } from "./PlantTechnicalSheet";
+import { ImageInfo } from "./ImageInfo";
+import { EnumColumn } from "./utils/enumColumn";
+
+@Entity("fertilization_info")
+export class FertilizationInfo implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idFertilizationInfo!: number;
+
+  /** Tipo de fertilizante según catálogo */
+  @EnumColumn(Object.keys(FERTILIZER_TYPE) as FertilizerType[])
+  type!: FertilizerType;
+
+  /** Frecuencia de aplicación según catálogo */
+  @EnumColumn(Object.keys(FERTILIZER_FREQ) as FertilizerFrequency[])
+  frequency!: FertilizerFrequency;
+
+  /** Método de aplicación según catálogo */
+  @EnumColumn(Object.keys(FERTILIZER_METHOD) as FertilizerMethod[])
+  method!: FertilizerMethod;
+
+  @Column("text", { nullable: true })
+  formula?: string;
+
+  @Column("text", { nullable: true })
+  notes?: string;
+
+  /** Imágenes asociadas */
+  @OneToMany(() => ImageInfo, (image) => image.fertilizationInfo)
+  images?: ImageInfo[];
+
+  @Column({ type: "boolean", default: true })
+  isActive!: boolean;
+}

package/src/models/technical-sheet/GrowthClassInfo.ts

@@ -0,0 +1,35 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    OneToMany,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { GROWTH_CLASS, GrowthClass } from './catalogs/growth-class';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('growth_class_info')
+  export class GrowthClassInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idGrowthClassInfo!: number;
+  
+    /** Clase de crecimiento (catálogo) */
+    @EnumColumn(Object.keys(GROWTH_CLASS) as GrowthClass[])
+    type!: GrowthClass;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    /** Imágenes asociadas */
+    @OneToMany(() => ImageInfo, (image) => image.growthClassInfo, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/HumidityInfo.ts

@@ -0,0 +1,31 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    OneToMany,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { HUMIDITY, HumidityRequirement } from './catalogs/humidity-info';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('humidity_info')
+  export class HumidityInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idHumidityInfo!: number;
+  
+    @EnumColumn(Object.keys(HUMIDITY) as HumidityRequirement[])
+    type!: HumidityRequirement;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.humidityInfo, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/ImageInfo.ts

@@ -0,0 +1,102 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ObjectLiteral,
+  ManyToOne,
+  JoinColumn,
+} from "typeorm";
+import { PlantTechnicalSheet } from "./PlantTechnicalSheet";
+import { PlantGrowthType } from "./PlantGrowthType";
+import { LightInfo } from "./LightInfo";
+import { HumidityInfo } from "./HumidityInfo";
+import { ClimateIdeal } from "./ClimateIdeal";
+import { SubstrateInfo } from "./SubstrateInfo";
+import { FertilizationInfo } from "./FertilizationInfo";
+import { PestInfo } from "./PestInfo";
+import { PropagationMethodInfo } from "./PropagationMethodInfo";
+import { PlantSize } from "./PlantSize";
+import { GrowthClassInfo } from "./GrowthClassInfo";
+
+@Entity("technical_sheet_images")
+export class ImageInfo implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idImage!: number;
+
+  @Column("varchar", { length: 500 })
+  url!: string;
+
+  @Column("text", { nullable: true })
+  description?: string;
+
+  @Column({ type: "boolean", default: true })
+  isActive!: boolean;
+
+  @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "plantTechnicalSheetId" })
+  plantTechnicalSheet?: PlantTechnicalSheet;
+
+  @ManyToOne(() => PlantGrowthType, (growthType) => growthType.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "plantGrowthTypeId" })
+  plantGrowthType?: PlantGrowthType;
+
+  @ManyToOne(() => LightInfo, (lightInfo) => lightInfo.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "lightInfoId" })
+  lightInfo?: LightInfo;
+
+  @ManyToOne(() => HumidityInfo, (humidityInfo) => humidityInfo.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "humidityInfoId" })
+  humidityInfo?: HumidityInfo;
+
+  @ManyToOne(() => ClimateIdeal, (climate) => climate.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "climateIdealId" })
+  climateIdeal?: ClimateIdeal;
+
+  @ManyToOne(() => SubstrateInfo, (substrate) => substrate.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "substrateInfoId" })
+  substrateInfo?: SubstrateInfo;
+
+  @ManyToOne(() => FertilizationInfo, (f) => f.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "fertilizationInfoId" })
+  fertilizationInfo?: FertilizationInfo;
+
+  @ManyToOne(() => PestInfo, (pest) => pest.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "pestId" })
+  pest?: PestInfo;
+
+  @ManyToOne(() => PropagationMethodInfo, (info) => info.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "propagationMethodId" })
+  propagationMethod?: PropagationMethodInfo;
+
+  @ManyToOne(() => PlantSize, (size) => size.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "plantSizeId" })
+  plantSize?: PlantSize;
+
+  @ManyToOne(() => GrowthClassInfo, (growthClass) => growthClass.images, {
+    nullable: true,
+  })
+  @JoinColumn({ name: "growthClassInfoId" })
+  growthClassInfo?: GrowthClassInfo;
+}
+

package/src/models/technical-sheet/LightInfo.ts

@@ -0,0 +1,31 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToMany,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { LIGHT, LightRequirement } from './catalogs/light-info';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('light_info')
+  export class LightInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idLightInfo!: number;
+  
+    @EnumColumn(Object.keys(LIGHT) as LightRequirement[])
+    type!: LightRequirement;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.lightInfo, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PestInfo.ts

@@ -0,0 +1,65 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ObjectLiteral,
+    ManyToOne,
+    JoinColumn,
+    OneToMany,
+  } from 'typeorm';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  import {
+    PEST_TYPE,
+    PestType,
+    PLANT_PART,
+    PlantPart,
+    CONTROL_METHOD,
+    ControlMethod,
+  } from './catalogs/pest-info';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('pests')
+  export class PestInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idPestInfo!: number;
+  
+    @Column('varchar', { length: 255 })
+    commonName!: string;
+  
+    @Column('varchar', { nullable: true, length: 255 })
+    scientificName?: string;
+  
+    @EnumColumn(Object.keys(PEST_TYPE) as PestType[])
+    type!: PestType;
+  
+    @EnumColumn(Object.keys(PLANT_PART) as PlantPart[])
+    affectedParts!: PlantPart;
+  
+    @Column('text')
+    symptoms!: string;
+  
+    @Column('text', { nullable: true })
+    appearanceConditions?: string;
+  
+    @EnumColumn(Object.keys(CONTROL_METHOD) as ControlMethod[])
+    controlMethod!: ControlMethod;
+  
+    @Column('text', { nullable: true })
+    controlNotes?: string;
+  
+    @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.pests, {
+      onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'technicalSheetId' })
+    technicalSheet!: PlantTechnicalSheet;
+  
+    @OneToMany(() => ImageInfo, (image) => image.pest, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PlantGrowthType.ts

@@ -0,0 +1,38 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ObjectLiteral,
+    OneToMany,
+  } from 'typeorm';
+  import { EnumColumn } from './utils/enumColumn';
+  import { GROWTH_AREA, GROWTH_HABIT } from './catalogs/growth-type';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  
+  export type PlantGrowthArea = keyof typeof GROWTH_AREA;
+  export type PlantGrowthHabit = keyof typeof GROWTH_HABIT;
+  
+  @Entity('plant_growth_types')
+  export class PlantGrowthType implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idPlantGrowthType!: number;
+  
+    @EnumColumn(Object.keys(GROWTH_AREA) as PlantGrowthArea[])
+    area!: PlantGrowthArea;
+  
+    @EnumColumn(Object.keys(GROWTH_HABIT) as PlantGrowthHabit[])
+    habit!: PlantGrowthHabit;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.plantGrowthType, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PlantSize.ts

@@ -0,0 +1,41 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    ManyToOne,
+    OneToMany,
+    JoinColumn,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { GROWTH_HABIT_GEOM, GrowthHabit } from './catalogs/plant-size';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('plant_size')
+  export class PlantSize implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idPlantSize!: number;
+  
+    @Column('int')
+    heightCm!: number;
+  
+    @Column('int', { nullable: true })
+    widthCm?: number | null;
+  
+    @EnumColumn(Object.keys(GROWTH_HABIT_GEOM) as GrowthHabit[], { nullable: true })
+    habit?: GrowthHabit | undefined;
+  
+    @Column('text', { nullable: true })
+    notes?: string | null;
+  
+    @OneToMany(() => ImageInfo, (image) => image.plantSize, {
+      cascade: true,
+      nullable: true,
+    })
+    images?: ImageInfo[] | undefined;
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PlantTechnicalSheet.ts

@@ -0,0 +1,93 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ObjectLiteral,
+    OneToOne,
+    JoinColumn,
+    OneToMany,
+  } from "typeorm";
+  import { PlantGrowthType } from "./PlantGrowthType";
+  import { LightInfo } from "./LightInfo";
+  import { HumidityInfo } from "./HumidityInfo";
+  import { ClimateIdeal } from "./ClimateIdeal";
+  import { SubstrateInfo } from "./SubstrateInfo";
+  import { FertilizationInfo } from "./FertilizationInfo";
+  import { PestInfo } from "./PestInfo";
+  import { CareInstructions } from "./CareInstructions";
+  import { PropagationMethodInfo } from "./PropagationMethodInfo";
+  import { PlantSize } from "./PlantSize";
+  import { GrowthClassInfo } from "./GrowthClassInfo";
+  import { ImageInfo } from "./ImageInfo";
+  
+  @Entity("plant_technical_sheets")
+  export class PlantTechnicalSheet implements ObjectLiteral {
+    @PrimaryGeneratedColumn("increment")
+    idPlantTechnicalSheet!: number;
+  
+    @Column("varchar", { length: 255 })
+    commonName!: string;
+  
+    @Column("varchar", { length: 255 })
+    scientificName!: string;
+  
+    @Column("varchar", { length: 255 })
+    origin!: string;
+  
+    @OneToOne(() => PlantGrowthType, { cascade: true })
+    @JoinColumn({ name: "plantGrowthTypeId" })
+    plantType!: PlantGrowthType;
+  
+    @OneToOne(() => LightInfo, { cascade: true })
+    @JoinColumn({ name: "lightInfoId" })
+    light!: LightInfo;
+  
+    @OneToOne(() => HumidityInfo, { cascade: true })
+    @JoinColumn({ name: "humidityInfoId" })
+    humidity!: HumidityInfo;
+  
+    @OneToOne(() => ClimateIdeal, { cascade: true })
+    @JoinColumn({ name: "climateIdealId" })
+    climate!: ClimateIdeal;
+  
+    @OneToOne(() => SubstrateInfo, { cascade: true })
+    @JoinColumn({ name: "substrateInfoId" })
+    substrate!: SubstrateInfo;
+  
+    @OneToOne(() => FertilizationInfo, { cascade: true })
+    @JoinColumn({ name: "fertilizationInfoId" })
+    fertilization!: FertilizationInfo;
+  
+    @OneToMany(() => PestInfo, (pest) => pest.technicalSheet, {
+      cascade: true,
+    })
+    pests!: PestInfo[];
+  
+    @OneToOne(() => CareInstructions, { cascade: true })
+    @JoinColumn({ name: "careInstructionsId" })
+    care!: CareInstructions;
+  
+    @OneToOne(() => PropagationMethodInfo, { cascade: true })
+    @JoinColumn({ name: "propagationMethodId" })
+    propagation!: PropagationMethodInfo;
+  
+    @OneToOne(() => PlantSize, { cascade: true })
+    @JoinColumn({ name: "plantSizeId" })
+    size!: PlantSize;
+  
+    @OneToOne(() => GrowthClassInfo, { cascade: true })
+    @JoinColumn({ name: "growthClassInfoId" })
+    growthClass!: GrowthClassInfo;
+  
+    @OneToMany(() => ImageInfo, (img) => img.plantTechnicalSheet, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column("text", { nullable: true })
+    notes?: string;
+  
+    @Column({ type: "boolean", default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PropagationMethodInfo.ts

@@ -0,0 +1,33 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  OneToMany,
+  ObjectLiteral,
+} from "typeorm";
+import { PropagationMethod, PROPAGATION } from "./catalogs/propagation-method";
+import { ImageInfo } from "./ImageInfo";
+import { EnumColumn } from "./utils/enumColumn";
+
+@Entity("propagation_method_info")
+export class PropagationMethodInfo implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idPropagationMethodInfo!: number;
+
+  @EnumColumn(Object.keys(PROPAGATION) as PropagationMethod[], {
+    nullable: false,
+  })
+  type!: PropagationMethod | undefined;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @OneToMany(() => ImageInfo, (image) => image.propagationMethod, {
+    cascade: true,
+    nullable: true,
+  })
+  images?: ImageInfo[] | undefined;
+
+  @Column({ type: "boolean", default: true })
+  isActive?: boolean | undefined;
+}

package/src/models/technical-sheet/SubstrateInfo.ts

@@ -0,0 +1,36 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToMany,
+    ObjectLiteral,
+} from 'typeorm';
+import { SubstrateType, SUBSTRATE } from './catalogs/substrate-info';
+import { ImageInfo } from './ImageInfo';
+
+import { EnumColumn } from './utils/enumColumn';
+
+  @Entity('substrate_info')
+  export class SubstrateInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idSubstrateInfo!: number;
+  
+    @EnumColumn(Object.keys(SUBSTRATE) as SubstrateType[])
+    type!: SubstrateType;
+  
+    @Column('text', { nullable: true })
+    recipe?: string;
+  
+    @Column('text', { nullable: true })
+    notes?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.substrateInfo, {
+      cascade: true,
+      nullable: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+