@tabletennisshop/common 1.0.17 → 1.0.18

package/build/enums/order-status.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum OrderStatusEnum {
+    Pending = "pending",// Order placed but not yet processed
+    Confirmed = "confirmed",
+    Delivering = "delivering",// Order is being shipped
+    Finished = "finished",// Order completed/delivered
+    Cancelled = "cancelled",// Order canceled by user or system
+    Returned = "returned",
+    Failed = "failed"
+}

package/build/enums/order-status.enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderStatusEnum = void 0;
+var OrderStatusEnum;
+(function (OrderStatusEnum) {
+    OrderStatusEnum["Pending"] = "pending";
+    OrderStatusEnum["Confirmed"] = "confirmed";
+    OrderStatusEnum["Delivering"] = "delivering";
+    OrderStatusEnum["Finished"] = "finished";
+    OrderStatusEnum["Cancelled"] = "cancelled";
+    OrderStatusEnum["Returned"] = "returned";
+    OrderStatusEnum["Failed"] = "failed";
+})(OrderStatusEnum || (exports.OrderStatusEnum = OrderStatusEnum = {}));

package/build/enums/payment-method.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum PaymentMethodEnum {
+    Banking = "banking",
+    COD = "cod"
+}

package/build/enums/payment-method.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodEnum = void 0;
+var PaymentMethodEnum;
+(function (PaymentMethodEnum) {
+    PaymentMethodEnum["Banking"] = "banking";
+    PaymentMethodEnum["COD"] = "cod";
+})(PaymentMethodEnum || (exports.PaymentMethodEnum = PaymentMethodEnum = {}));

package/build/enums/user.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum UserEnum {
+    Client = "client",
+    Admin = "admin",
+    Employee = "employee"
+}

package/build/enums/user.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserEnum = void 0;
+var UserEnum;
+(function (UserEnum) {
+    UserEnum["Client"] = "client";
+    UserEnum["Admin"] = "admin";
+    UserEnum["Employee"] = "employee";
+})(UserEnum || (exports.UserEnum = UserEnum = {}));

package/build/index.d.ts

@@ -6,7 +6,7 @@ export * from './middlewares/check-authorized-middleware';
 export * from './middlewares/error-handler';
 export * from './middlewares/validate-request-middleware';
 export * from './middlewares/current-user-middleware';
-export * from './models/client.model';
+export * from './models/user.model';
 export * from './models/product.model';
 export * from './models/racket.model';
 export * from './models/shirt.model';

package/build/index.js

@@ -22,7 +22,7 @@ __exportStar(require("./middlewares/check-authorized-middleware"), exports);
 __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/validate-request-middleware"), exports);
 __exportStar(require("./middlewares/current-user-middleware"), exports);
-__exportStar(require("./models/client.model"), exports);
+__exportStar(require("./models/user.model"), exports);
 __exportStar(require("./models/product.model"), exports);
 __exportStar(require("./models/racket.model"), exports);
 __exportStar(require("./models/shirt.model"), exports);

package/build/models/address.schema.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from "mongoose";
+export interface IAddress {
+    province: string;
+    district: string;
+    ward: string;
+    phone_number: string;
+}
+export declare const AddressSchema: Schema<IAddress, import("mongoose").Model<IAddress, any, any, any, import("mongoose").Document<unknown, any, IAddress, any> & IAddress & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAddress, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAddress>, {}> & import("mongoose").FlatRecord<IAddress> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/build/models/address.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.AddressSchema = new mongoose_1.Schema({
+    province: { type: String, required: true },
+    district: { type: String, required: true },
+    ward: { type: String, required: true },
+    phone_number: { type: String, required: true },
+}, { _id: false } //This schema don't need Address Schema
+);

package/build/models/cart.model.d.ts

@@ -0,0 +1,24 @@
+import { Document, Model, Types } from "mongoose";
+interface CartAttrs {
+    user_id: Types.ObjectId;
+    products: [
+        {
+            product_id: Types.ObjectId;
+            quantity: number;
+        }
+    ];
+}
+interface CartDoc extends Document {
+    user_id: Types.ObjectId;
+    products: [
+        {
+            product_id: Types.ObjectId;
+            quantity: number;
+        }
+    ];
+}
+interface CartModel extends Model<CartDoc> {
+    build(attrs: CartAttrs): CartDoc;
+}
+export declare const CartModel: CartModel;
+export {};

package/build/models/cart.model.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartModel = void 0;
+const mongoose_1 = require("mongoose");
+const CartSchema = new mongoose_1.Schema({
+    user_id: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', required: true },
+    products: {
+        type: [{
+                product_id: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Product', required: true },
+                quantity: { type: Number, required: true }
+            }],
+        required: true
+    }
+}, {
+    collection: "cart"
+});
+CartSchema.statics.build = (attrs) => {
+    return new exports.CartModel(attrs);
+};
+exports.CartModel = (0, mongoose_1.model)('Cart', CartSchema);

package/build/models/order.model.d.ts

@@ -0,0 +1,30 @@
+import { Document, Model, Types } from 'mongoose';
+import { IAddress } from './address.schema';
+import { OrderStatusEnum } from '../enums/order-status.enum';
+import { IStatusTimestamps } from './status-timestamp.schema';
+import { PaymentMethodEnum } from '../enums/payment-method.enum';
+interface IOrderProduct {
+    product_id: Types.ObjectId;
+    quantity: number;
+}
+export interface OrderAttrs {
+    user_id: Types.ObjectId;
+    address: IAddress;
+    products: IOrderProduct[];
+    status: OrderStatusEnum;
+    statusTimestamps: IStatusTimestamps;
+    payment_method: PaymentMethodEnum;
+}
+export interface OrderDoc extends Document {
+    user_id: Types.ObjectId;
+    address: IAddress;
+    products: IOrderProduct[];
+    status?: OrderStatusEnum;
+    statusTimestamps: IStatusTimestamps;
+    payment_method: PaymentMethodEnum;
+}
+interface OrderModel extends Model<OrderDoc> {
+    build(attrs: OrderAttrs): OrderDoc;
+}
+export declare const OrderModel: OrderModel;
+export {};

package/build/models/order.model.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderModel = void 0;
+const mongoose_1 = require("mongoose");
+const address_schema_1 = require("./address.schema");
+const status_timestamp_schema_1 = require("./status-timestamp.schema");
+const payment_method_enum_1 = require("../enums/payment-method.enum");
+const OrderSchema = new mongoose_1.Schema({
+    user_id: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', required: true }, // FK to User
+    address: { type: address_schema_1.AddressSchema, required: true },
+    products: [
+        {
+            product_id: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Product', required: true }, // FK to Product
+            quantity: { type: Number, required: true },
+        },
+    ],
+    status: { type: String, required: true },
+    statusTimestamps: { type: status_timestamp_schema_1.StatusTimestampsSchema, require: true },
+    payment_method: { type: String, enum: payment_method_enum_1.PaymentMethodEnum, required: true }
+}, { collection: 'order' });
+OrderSchema.statics.build = (attrs) => {
+    return new exports.OrderModel(attrs);
+};
+exports.OrderModel = (0, mongoose_1.model)('Order', OrderSchema);

package/build/models/product.model.d.ts

@@ -4,7 +4,8 @@ export interface ProductAttrsBase {
     name: string;
     brand: string;
     description: string;
-    details: any;
+    sport: string;
+    attributes: any;
     price: number;
 }
 export interface ProductDoc extends Document {
@@ -12,7 +13,9 @@ export interface ProductDoc extends Document {
     brand: string;
     description: string;
     type: ProductEnum;
-    details: any;
+    sport: string;
+    attributes: any;
+    slug: string;
     price: number;
 }
 export declare const ProductModel: mongoose.Model<ProductDoc, {}, {}, {}, mongoose.Document<unknown, {}, ProductDoc, {}> & ProductDoc & Required<{

package/build/models/product.model.js

@@ -32,30 +32,50 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProductModel = void 0;
 // src/models/product.model.ts
 const mongoose_1 = __importStar(require("mongoose"));
-const product_enum_1 = require("../enums/product.enum");
-const AutoIncrement = require('mongoose-sequence')(mongoose_1.default);
 //We don't need "interface ProductModel extends Model<>" for this
 const baseOptions = {
     discriminatorKey: 'type',
-    collection: 'products',
-    _id: false,
+    collection: 'product',
+    timestamps: true
 };
 const ProductSchema = new mongoose_1.Schema({
-    _id: { type: Number },
-    name: { type: String, required: true },
+    name: { type: String, required: true, unique: true },
     brand: { type: String, required: true },
     description: { type: String, required: false },
-    type: { type: String, enum: Object.values(product_enum_1.ProductEnum), required: true },
-    details: { type: [mongoose_1.Schema.Types.Mixed], require: false },
+    type: { type: String, required: true },
+    sport: { type: String, required: true },
+    attributes: { type: [mongoose_1.Schema.Types.Mixed], require: false },
+    slug: { type: String, required: true, unique: true },
     price: { type: Number, require: true }
 }, baseOptions);
-/*
-  inc_field is the field in the Collections
-  id: This must be unique in each Incremental Fields
-*/
-ProductSchema.plugin(AutoIncrement, { inc_field: '_id', id: "product_id_seq" });
+ProductSchema.pre("save", function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.isModified('name') || !this.slug) {
+            this.slug = generateUniqueSlug(this.name);
+        }
+        next();
+    });
+});
 exports.ProductModel = mongoose_1.default.model('Product', ProductSchema);
+const generateUniqueSlug = (name, currentId) => {
+    const baseSlug = name
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, '') // remove non-word characters
+        .replace(/\s+/g, '-') // replace spaces with hyphens
+        .replace(/-+/g, '-'); // collapse multiple hyphens
+    return baseSlug;
+};

package/build/models/status-timestamp.schema.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "mongoose";
+export interface IStatusTimestamps {
+    pending_at?: Date;
+    confirmed_at?: Date;
+    delivering_at?: Date;
+    finished_at?: Date;
+    cancelled_at?: Date;
+    returned_at?: Date;
+    failed_at?: Date;
+}
+export declare const StatusTimestampsSchema: Schema<IStatusTimestamps, import("mongoose").Model<IStatusTimestamps, any, any, any, import("mongoose").Document<unknown, any, IStatusTimestamps, any> & IStatusTimestamps & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IStatusTimestamps, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IStatusTimestamps>, {}> & import("mongoose").FlatRecord<IStatusTimestamps> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/build/models/status-timestamp.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusTimestampsSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.StatusTimestampsSchema = new mongoose_1.Schema({
+    pending_at: { type: Date },
+    confirmed_at: { type: Date },
+    delivering_at: { type: Date },
+    finished_at: { type: Date },
+    cancelled_at: { type: Date },
+    returned_at: { type: Date },
+    failed_at: { type: Date },
+}, { _id: false });

package/build/models/{client.model.d.ts → user.model.d.ts}

@@ -1,26 +1,30 @@
 import { Model, Document } from 'mongoose';
-export interface ClientAttrs {
+import { IAddress } from './address.schema';
+export interface UserAttrs {
     email: string;
     password: string;
     full_name: string;
-    address: string;
+    addresses: IAddress[];
+    type: string;
     province: string;
     district: string;
     ward: string;
     phone_number: string;
+    status: string;
 }
-interface ClientDoc extends Document {
+interface UserDoc extends Document {
     email: string;
     password: string;
     full_name: string;
-    address: string;
+    addresses: IAddress[];
+    type: string;
     province: string;
     district: string;
     ward: string;
     phone_number: string;
 }
-interface ClientModel extends Model<ClientDoc> {
-    build(attrs: ClientAttrs): ClientDoc;
+interface UserModel extends Model<UserDoc> {
+    build(attrs: UserAttrs): UserDoc;
 }
-export declare const ClientModel: ClientModel;
+export declare const UserModel: UserModel;
 export {};

package/build/models/user.model.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = void 0;
+const mongoose_1 = require("mongoose");
+const password_1 = require("../services/password");
+const user_enum_1 = require("../enums/user.enum");
+const address_schema_1 = require("./address.schema");
+const UserSchema = new mongoose_1.Schema({
+    email: { type: String, required: true, unique: true },
+    password: { type: String, required: true, minlength: 4 },
+    full_name: { type: String, required: true },
+    addresses: [
+        { type: address_schema_1.AddressSchema, required: true }
+    ],
+    type: { type: String, enum: Object.values(user_enum_1.UserEnum), required: true },
+}, {
+    timestamps: true, // Adds createdAt and updatedAt fields automatically
+    collection: "user"
+});
+UserSchema.statics.build = (attrs) => {
+    return new exports.UserModel(attrs);
+};
+UserSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.isModified('email')) {
+            const existingUser = yield exports.UserModel.findOne({ email: this.email });
+            if (existingUser) {
+                throw new Error("Email already exists!");
+            }
+        }
+        if (this.isModified('password')) {
+            this.password = yield password_1.Password.toHash(this.password);
+        }
+        next();
+    });
+});
+exports.UserModel = (0, mongoose_1.model)('User', UserSchema);

package/build/models/vendor-purchased.d.ts

@@ -0,0 +1,18 @@
+import { Types, Document } from 'mongoose';
+interface IVendorPurchase {
+    vendor_id: Types.ObjectId;
+    products: {
+        product_id: Types.ObjectId;
+        price: number;
+        quantity: number;
+    }[];
+    date: Date;
+}
+interface VendorPurchaseDoc extends IVendorPurchase, Document {
+}
+export declare const VendorPurchaseModel: import("mongoose").Model<VendorPurchaseDoc, {}, {}, {}, Document<unknown, {}, VendorPurchaseDoc, {}> & VendorPurchaseDoc & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, any>;
+export {};

package/build/models/vendor-purchased.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VendorPurchaseModel = void 0;
+const mongoose_1 = require("mongoose");
+const VendorPurchaseSchema = new mongoose_1.Schema({
+    vendor_id: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Vendor', required: true },
+    products: [
+        {
+            product_id: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Product', required: true },
+            price: { type: Number, required: true },
+            quantity: { type: Number, required: true },
+        },
+    ],
+    date: { type: Date, required: true },
+}, {
+    collection: 'vendor_purchase',
+    timestamps: true,
+});
+exports.VendorPurchaseModel = (0, mongoose_1.model)('VendorPurchase', VendorPurchaseSchema);

package/build/models/vendor.model.d.ts

@@ -0,0 +1,15 @@
+import { Document, Model } from "mongoose";
+import { IAddress } from "./address.schema";
+interface VendorAttrs {
+    name: string;
+    address: IAddress;
+}
+interface VendorDoc extends Document {
+    name: string;
+    address: IAddress;
+}
+interface VendorModel extends Model<VendorDoc> {
+    build(attr: VendorAttrs): VendorDoc;
+}
+export declare const VendorModel: VendorModel;
+export {};

package/build/models/vendor.model.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VendorModel = void 0;
+const mongoose_1 = require("mongoose");
+const address_schema_1 = require("./address.schema");
+const VendorSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    address: { type: address_schema_1.AddressSchema, required: true }
+}, {
+    timestamps: true,
+    collection: "vendor"
+});
+VendorSchema.statics.build = (attrs) => {
+    return new exports.VendorModel(attrs);
+};
+exports.VendorModel = (0, mongoose_1.model)('Vendor', VendorSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tabletennisshop/common",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "",
   "main": "./build/index.js",
   "types": "build/index.d.ts",

package/build/models/client.model.js

@@ -1,81 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientModel = void 0;
-const mongoose_1 = __importStar(require("mongoose"));
-const password_1 = require("../services/password");
-const AutoIncrement = require('mongoose-sequence')(mongoose_1.default);
-const ClientSchema = new mongoose_1.Schema({
-    _id: { type: Number },
-    email: { type: String, required: true, unique: true },
-    password: { type: String, required: true, minlength: 4 },
-    full_name: { type: String, required: true },
-    address: { type: String, required: true },
-    province: { type: String, required: true },
-    district: { type: String, required: true },
-    ward: { type: String, required: true },
-    phone_number: { type: String, required: true }
-}, {
-    timestamps: true, // Adds createdAt and updatedAt fields automatically
-    _id: false
-});
-ClientSchema.plugin(AutoIncrement, { inc_field: '_id', id: "client_id_seq" });
-ClientSchema.statics.build = (attrs) => {
-    return new exports.ClientModel(attrs);
-};
-ClientSchema.pre('save', function (next) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (this.isModified('email')) {
-            const existingUser = yield exports.ClientModel.findOne({ email: this.email });
-            if (existingUser) {
-                throw new Error("Email already exists!");
-            }
-        }
-        if (this.isModified('password')) {
-            this.password = yield password_1.Password.toHash(this.password);
-        }
-        next();
-    });
-});
-exports.ClientModel = (0, mongoose_1.model)('Client', ClientSchema);