proflores-db-model 0.1.33 → 0.2.0

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PEST_TYPE = exports.CONTROL_METHOD = exports.PLANT_PART = void 0;
+const makeCatalog_1 = require("../utils/makeCatalog");
+exports.PLANT_PART = (0, makeCatalog_1.makeCatalog)({
+    HOJAS: 'Hojas.',
+    TALLOS: 'Tallos.',
+    RAÍCES: 'Raíces.',
+    FLORES: 'Flores.',
+    FRUTOS: 'Frutos.',
+    TODA_LA_PLANTA: 'Daño sistémico.',
+});
+exports.CONTROL_METHOD = (0, makeCatalog_1.makeCatalog)({
+    JABÓN_POTÁSICO: 'Insecticida suave.',
+    ACEITE_DE_NEEM: 'Azadiractina sistémica.',
+    INSECTICIDA_SISTÉMICO: 'Absorción interna.',
+    INSECTICIDA_CONTACTO: 'Mata por contacto.',
+    FUNGICIDA_SISTÉMICO: 'Control interno hongos.',
+    FUNGICIDA_CONTACTO: 'Barrera superficial.',
+    TRAMPAS: 'Captura física.',
+    PODA_SANITARIA: 'Eliminación partes infectadas.',
+    CONTROL_BIOLÓGICO: 'Depredadores benéficos.',
+    OTRO: 'Otro método.',
+});
+exports.PEST_TYPE = (0, makeCatalog_1.makeCatalog)({
+    INSECTO: 'Insectos.',
+    HONGO: 'Hongos.',
+    ÁCARO: 'Aácaros.',
+    BACTERIA: 'Bacterias.',
+    VIRUS: 'Virus.',
+    NEMATODO: 'Nematodos.',
+    OTRO: 'Otro.',
+});

package/dist/models/technical-sheet/catalogs/plant-size.d.ts

@@ -0,0 +1,11 @@
+export declare const GROWTH_HABIT_GEOM: {
+    COMPACTA: string;
+    EXPANSIVA: string;
+    ERECTA: string;
+    RASERA: string;
+    TREPADORA: string;
+    COLGANTE: string;
+    ARBUSTIVA: string;
+    ARBOREA: string;
+};
+export type GrowthHabit = keyof typeof GROWTH_HABIT_GEOM;

package/dist/models/technical-sheet/catalogs/plant-size.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GROWTH_HABIT_GEOM = void 0;
+// src/models/technical-sheet/catalogs/plant-size.ts
+const makeCatalog_1 = require("../utils/makeCatalog");
+exports.GROWTH_HABIT_GEOM = (0, makeCatalog_1.makeCatalog)({
+    COMPACTA: 'Poco volumen.',
+    EXPANSIVA: 'Brotes laterales extensos.',
+    ERECTA: 'Vertical sin soporte.',
+    RASERA: 'Se extiende sobre el suelo.',
+    TREPADORA: 'Escala estructuras.',
+    COLGANTE: 'Tallos péndulos.',
+    ARBUSTIVA: 'Múltiples ramas leñosas.',
+    ARBOREA: 'Tronco leñoso único.',
+});

package/dist/models/technical-sheet/catalogs/propagation-method.d.ts

@@ -0,0 +1,14 @@
+export declare const PROPAGATION: {
+    ESQUEJE_TALLO: string;
+    ESQUEJE_HOJA: string;
+    ESQUEJE_RAÍZ: string;
+    SEMILLA: string;
+    DIVISIÓN_MATA: string;
+    ACODO_SIMPLE: string;
+    ACODO_AÉREO: string;
+    IN_VITRO: string;
+    BULBO_RIZOMA_TUBÉRCULO: string;
+    HIJUELOS: string;
+    NO_APLICA: string;
+};
+export type PropagationMethod = keyof typeof PROPAGATION;

package/dist/models/technical-sheet/catalogs/propagation-method.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROPAGATION = void 0;
+// src/models/technical-sheet/catalogs/propagation-method.ts
+const makeCatalog_1 = require("../utils/makeCatalog");
+exports.PROPAGATION = (0, makeCatalog_1.makeCatalog)({
+    ESQUEJE_TALLO: 'Corte de tallo.',
+    ESQUEJE_HOJA: 'Esqueje de hoja.',
+    ESQUEJE_RAÍZ: 'Fragmento de raíz.',
+    SEMILLA: 'Propagación sexual.',
+    DIVISIÓN_MATA: 'División de mata.',
+    ACODO_SIMPLE: 'Acodo simple.',
+    ACODO_AÉREO: 'Acodo aéreo.',
+    IN_VITRO: 'Cultivo in vitro.',
+    BULBO_RIZOMA_TUBÉRCULO: 'Órgano subterráneo.',
+    HIJUELOS: 'Brotes basales.',
+    NO_APLICA: 'No aplicable.',
+});

package/dist/models/technical-sheet/catalogs/substrate-info.d.ts

@@ -0,0 +1,17 @@
+export declare const SUBSTRATE: {
+    UNIVERSAL: string;
+    INTERIOR_LIGERO: string;
+    CACTUS_SUCULENTAS: string;
+    ORQUÍDEAS_EPÍFITAS: string;
+    BROMELIAS: string;
+    ACUÁTICO: string;
+    HELECHOS_HUMEDOS: string;
+    SEMILLERO: string;
+    BONSAI: string;
+    HIDROPONÍA: string;
+    ARENA_GRAVILLA: string;
+    FIBRA_COCO_PURA: string;
+    TURBA: string;
+    COMPOST_HOJARASCA: string;
+};
+export type SubstrateType = keyof typeof SUBSTRATE;

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.d.ts

@@ -0,0 +1,7 @@
+export declare enum MovementType {
+    PURCHASE = "PURCHASE",
+    SALE = "SALE",
+    ADJUSTMENT = "ADJUSTMENT",
+    TRANSFER_IN = "TRANSFER_IN",
+    TRANSFER_OUT = "TRANSFER_OUT"
+}

package/dist/types/MovementType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MovementType = void 0;
+var MovementType;
+(function (MovementType) {
+    MovementType["PURCHASE"] = "PURCHASE";
+    MovementType["SALE"] = "SALE";
+    MovementType["ADJUSTMENT"] = "ADJUSTMENT";
+    MovementType["TRANSFER_IN"] = "TRANSFER_IN";
+    MovementType["TRANSFER_OUT"] = "TRANSFER_OUT";
+})(MovementType || (exports.MovementType = MovementType = {}));

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export { ExpenseTransactionType } from "./ExpenseTransactionType";
 export { ExpenseDetailType } from "./ExpenseDetailType";
 export { ExpenseTypeType } from "./ExpenseTypeType";
 export { ProjectOrderType } from "./ProjectOrderType";
+export { MovementType } from "./MovementType";

package/dist/types/index.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MovementType = void 0;
+var MovementType_1 = require("./MovementType");
+Object.defineProperty(exports, "MovementType", { enumerable: true, get: function () { return MovementType_1.MovementType; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proflores-db-model",
-  "version": "0.1.33",
+  "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

@@ -13,6 +13,8 @@ import { Branch } from "./Branches";
 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")
@@ -58,4 +60,7 @@ export class Inventory implements ObjectLiteral {
     }
   )
   images!: InventoryImage[] | null;
+
+  @OneToMany(() => InventoryMovement, (movement) => movement.inventory)
+  movements!: InventoryMovement[];
 }

package/src/entities/InventoryMovement.ts

@@ -0,0 +1,52 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ManyToOne,
+    JoinColumn,
+    CreateDateColumn,
+    UpdateDateColumn,
+    ObjectLiteral,
+  } from "typeorm";
+  import { Inventory } from "./Inventory";
+  import { MovementType } from "../types/MovementType";
+  @Entity("inventory_movement")
+  export class InventoryMovement implements ObjectLiteral {
+    @PrimaryGeneratedColumn("increment")
+    idMovement!: number;
+  
+    @ManyToOne(() => Inventory, (inventory) => inventory.movements, {
+      nullable: false,
+    })
+    @JoinColumn({ name: "idInventory" })
+    inventory!: Inventory;
+  
+    @Column({
+      type: "enum",
+      enum: MovementType,
+    })
+    movementType!: MovementType;
+
+    @Column("decimal", { precision: 10, scale: 2, nullable: false, default: 0 })
+    quantityChange!: number;
+    
+    @Column("decimal", { precision: 10, scale: 2, nullable: true })
+    resultingStock?: number;
+  
+    @CreateDateColumn()
+    createdAt!: Date;
+  
+    @UpdateDateColumn()
+    updatedAt!: Date;
+  
+    @Column("varchar", { length: 255, nullable: true })
+    description?: string;
+  
+    @Column("int", { nullable: true })
+    referenceId?: number;
+  
+    @Column("varchar", { length: 50, nullable: true })
+    referenceModule?: string;
+  
+  }
+  

package/src/index.ts

@@ -14,9 +14,11 @@ export { TransactionBank } from "./entities/Bank/TransactionBank";
 export { ProductImage } from "./entities/ProductImage";
 export { Product } from "./entities/Products";
 export { Inventory } from "./entities/Inventory";
+export { InventoryMovement } from "./entities/InventoryMovement";
 export { Branch } from "./entities/Branches";
 export { BranchImage } from "./entities/BranchImage";
 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;
+  }
+