proflores-db-model 0.1.34 → 0.2.0

package/dist/models/technical-sheet/catalogs/substrate-info.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBSTRATE = void 0;
+// src/models/technical-sheet/catalogs/substrate-info.ts
+const makeCatalog_1 = require("../utils/makeCatalog");
+exports.SUBSTRATE = (0, makeCatalog_1.makeCatalog)({
+    UNIVERSAL: 'Mezcla equilibrada.',
+    INTERIOR_LIGERO: 'Turba + perlita.',
+    CACTUS_SUCULENTAS: 'Arena + grava, baja materia orgánica.',
+    ORQUÍDEAS_EPÍFITAS: 'Corteza gruesa + carbón.',
+    BROMELIAS: 'Fibra coco + corteza.',
+    ACUÁTICO: 'Arcilla y arena sumergida.',
+    HELECHOS_HUMEDOS: 'Turba + musgo esfagno.',
+    SEMILLERO: 'Turba fina esterilizada.',
+    BONSAI: 'Akadama + kiryuzuna + grava.',
+    HIDROPONÍA: 'Sustrato inerte.',
+    ARENA_GRAVILLA: '100 % mineral.',
+    FIBRA_COCO_PURA: 'Coco hidratado.',
+    TURBA: 'Turba rubia o negra.',
+    COMPOST_HOJARASCA: 'Orgánico descompuesto.',
+});

package/dist/models/technical-sheet/index.d.ts

@@ -0,0 +1,13 @@
+export * from './PlantTechnicalSheet';
+export * from './GrowthClassInfo';
+export * from './CareInstructions';
+export * from './ImageInfo';
+export * from './LightInfo';
+export * from './HumidityInfo';
+export * from './PestInfo';
+export * from './PlantGrowthType';
+export * from './PlantSize';
+export * from './SubstrateInfo';
+export * from './ClimateIdeal';
+export * from './FertilizationInfo';
+export * from './PropagationMethodInfo';

package/dist/models/technical-sheet/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PlantTechnicalSheet"), exports);
+__exportStar(require("./GrowthClassInfo"), exports);
+__exportStar(require("./CareInstructions"), exports);
+__exportStar(require("./ImageInfo"), exports);
+__exportStar(require("./LightInfo"), exports);
+__exportStar(require("./HumidityInfo"), exports);
+__exportStar(require("./PestInfo"), exports);
+__exportStar(require("./PlantGrowthType"), exports);
+__exportStar(require("./PlantSize"), exports);
+__exportStar(require("./SubstrateInfo"), exports);
+__exportStar(require("./ClimateIdeal"), exports);
+__exportStar(require("./FertilizationInfo"), exports);
+__exportStar(require("./PropagationMethodInfo"), exports);

package/dist/models/technical-sheet/utils/enumColumn.d.ts

@@ -0,0 +1,6 @@
+import { ColumnOptions } from "typeorm";
+/**
+ * Utilidad para columnas enum basadas en catálogos TypeScript.
+ * Permite usar `keyof typeof ENUM` como tipo en la entidad.
+ */
+export declare function EnumColumn<T extends string>(values: readonly T[], options?: Omit<ColumnOptions, "type" | "enum">): PropertyDecorator;

package/dist/models/technical-sheet/utils/enumColumn.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumColumn = EnumColumn;
+// src/models/technical-sheet/utils/enumColumn.ts
+const typeorm_1 = require("typeorm");
+/**
+ * Utilidad para columnas enum basadas en catálogos TypeScript.
+ * Permite usar `keyof typeof ENUM` como tipo en la entidad.
+ */
+function EnumColumn(values, options = {}) {
+    return (0, typeorm_1.Column)(Object.assign({ type: "enum", enum: values }, options));
+}

package/dist/models/technical-sheet/utils/makeCatalog.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Define un catálogo estático e inmutable y devuelve el mismo objeto.
+ * TypeScript infiere correctamente los tipos de clave.
+ *
+ * @param c Objeto Record<string, string> que representa el catálogo
+ * @returns El mismo objeto `c`, como constante tipada
+ */
+export declare function makeCatalog<C extends Record<string, string>>(c: C): C;

package/dist/models/technical-sheet/utils/makeCatalog.js

@@ -0,0 +1,19 @@
+"use strict";
+/* =============================================================================
+ *  UTILITY ─────────────  makeCatalog
+ * ---------------------------------------------------------------------------
+ *  Crea un Record<K, string> inmutable para catálogos
+ *  y permite derivar tipos clave (keyof).
+ * ===========================================================================*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCatalog = makeCatalog;
+/**
+ * Define un catálogo estático e inmutable y devuelve el mismo objeto.
+ * TypeScript infiere correctamente los tipos de clave.
+ *
+ * @param c Objeto Record<string, string> que representa el catálogo
+ * @returns El mismo objeto `c`, como constante tipada
+ */
+function makeCatalog(c) {
+    return c;
+}

package/dist/types/MovementType.js

@@ -8,4 +8,4 @@ var MovementType;
     MovementType["ADJUSTMENT"] = "ADJUSTMENT";
     MovementType["TRANSFER_IN"] = "TRANSFER_IN";
     MovementType["TRANSFER_OUT"] = "TRANSFER_OUT";
-})(MovementType = exports.MovementType || (exports.MovementType = {}));
+})(MovementType || (exports.MovementType = MovementType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proflores-db-model",
-  "version": "0.1.34",
+  "version": "0.2.0",
   "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,52 @@
+// 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;
+  
+    /** Relación inversa con la ficha técnica */
+    @OneToOne(() => PlantTechnicalSheet, (sheet) => sheet.care, {
+      onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'plantTechnicalSheetId' })
+    plantTechnicalSheet?: PlantTechnicalSheet;
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

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

@@ -0,0 +1,34 @@
+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, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

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

@@ -0,0 +1,59 @@
+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, {
+    cascade: true,
+  })
+  images?: ImageInfo[];
+
+  /** Ficha técnica a la que pertenece esta fertilización */
+  @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.fertilization, {
+    nullable: false,
+    onDelete: "CASCADE",
+  })
+  plant!: PlantTechnicalSheet;
+
+  @Column({ type: "boolean", default: true })
+  isActive!: boolean;
+}

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

@@ -0,0 +1,38 @@
+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[];
+  
+    /** Fichas técnicas asociadas */
+    @OneToMany(() => PlantTechnicalSheet, (sheet) => sheet.growthClass)
+    sheets!: PlantTechnicalSheet[];
+  
+    @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,111 @@
+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,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "plantGrowthTypeId" })
+  plantGrowthType?: PlantGrowthType;
+
+  @ManyToOne(() => LightInfo, (lightInfo) => lightInfo.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "lightInfoId" })
+  lightInfo?: LightInfo;
+
+  @ManyToOne(() => HumidityInfo, (humidityInfo) => humidityInfo.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "humidityInfoId" })
+  humidityInfo?: HumidityInfo;
+
+  @ManyToOne(() => ClimateIdeal, (climate) => climate.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "climateIdealId" })
+  climateIdeal?: ClimateIdeal;
+
+  @ManyToOne(() => SubstrateInfo, (substrate) => substrate.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "substrateInfoId" })
+  substrateInfo?: SubstrateInfo;
+
+  @ManyToOne(() => FertilizationInfo, (f) => f.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "fertilizationInfoId" })
+  fertilizationInfo?: FertilizationInfo;
+
+  @ManyToOne(() => PestInfo, (pest) => pest.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "pestId" })
+  pest?: PestInfo;
+
+  @ManyToOne(() => PropagationMethodInfo, (info) => info.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "propagationMethodId" })
+  propagationMethod?: PropagationMethodInfo;
+
+  @ManyToOne(() => PlantSize, (size) => size.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "plantSizeId" })
+  plantSize?: PlantSize;
+
+  @ManyToOne(() => GrowthClassInfo, (growthClass) => growthClass.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @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,41 @@
+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[];
+  
+    @OneToMany(() => PlantTechnicalSheet, (sheet) => sheet.plantType)
+    sheets!: PlantTechnicalSheet[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+