@nyig/models 0.2.22 → 0.2.24

package/index.js

@@ -59,6 +59,7 @@ __export(src_exports, {
   zMSemester: () => zMSemester,
   zMStudent: () => zMStudent,
   zMTConfig: () => zMTConfig,
+  zMTConfigResponse: () => zMTConfigResponse,
   zMTReg: () => zMTReg,
   zMTTicket: () => zMTTicket,
   zMTeacher: () => zMTeacher,
@@ -71,6 +72,7 @@ __export(src_exports, {
   zSemester: () => zSemester,
   zStudent: () => zStudent,
   zTConfig: () => zTConfig,
+  zTConfigResponse: () => zTConfigResponse,
   zTReg: () => zTReg,
   zTTicket: () => zTTicket,
   zTTicketReg: () => zTTicketReg,
@@ -220,24 +222,24 @@ var zDiscount = import_zod7.z.object({
   amount: import_zod7.z.number()
 });
 var zInvoiceItem = import_zod7.z.object({
-  course: import_zod7.z.instanceof(import_mongoose7.Types.ObjectId).or(import_zod7.z.string()),
+  course: import_zod7.z.string().min(1),
   price: import_zod7.z.number(),
   units: import_zod7.z.number()
 });
 var zInvoicePackage = import_zod7.z.object({
   student: import_zod7.z.instanceof(import_mongoose7.Types.ObjectId).or(import_zod7.z.string()),
-  items: import_zod7.z.array(zInvoiceItem)
+  items: import_zod7.z.array(zInvoiceItem).min(1, "Package must contain at least one item")
 });
 var zInvoice = import_zod7.z.object({
-  billTo: import_zod7.z.string(),
-  packages: import_zod7.z.array(zInvoicePackage),
+  billTo: import_zod7.z.string().min(1, "The 'Bill To' field must not be empty"),
+  packages: import_zod7.z.array(zInvoicePackage).min(1, "Invoice must include at least one package"),
   discounts: import_zod7.z.array(zDiscount),
-  textbook: import_zod7.z.number().int().min(1).optional(),
-  shipping: import_zod7.z.number().int().min(1).optional(),
+  textbook: import_zod7.z.number().int().min(0).optional(),
+  shipping: import_zod7.z.number().int().min(0).optional(),
   paid: import_zod7.z.nativeEnum(PaymentMethod).optional(),
   notes: import_zod7.z.string().optional(),
   createdBy: import_zod7.z.instanceof(import_mongoose7.Types.ObjectId).or(import_zod7.z.string()),
-  lastEditBy: import_zod7.z.instanceof(import_mongoose7.Types.ObjectId).optional()
+  lastEditBy: import_zod7.z.instanceof(import_mongoose7.Types.ObjectId).or(import_zod7.z.string()).optional()
 });
 var zMInvoice = extendZodObjectForMongoose(zInvoice);
 
@@ -483,8 +485,8 @@ var zSemester = import_zod19.z.object({
 var zMSemester = extendZodObjectForMongoose(zSemester);
 
 // src/interface/tournament/tConfig.ts
-var import_mongoose24 = require("mongoose");
-var import_zod21 = require("zod");
+var import_mongoose25 = require("mongoose");
+var import_zod22 = require("zod");
 
 // src/interface/tournament/table.ts
 var import_zod20 = require("zod");
@@ -495,44 +497,67 @@ var zDetailsTable = import_zod20.z.object({
 });
 var zScheduleTable = import_zod20.z.object({
   fields: import_zod20.z.array(import_zod20.z.string()).length(2),
-  data: import_zod20.z.map(import_zod20.z.string(), zTable)
+  data: import_zod20.z.record(import_zod20.z.string(), zTable)
+});
+
+// src/interface/tournament/tTicket.ts
+var import_zod21 = require("zod");
+var zTTicket = import_zod21.z.object({
+  name: import_zod21.z.string(),
+  /**
+   * Price in cents
+   */
+  price: import_zod21.z.number(),
+  /**
+   * @optional description of the ticket
+   */
+  description: import_zod21.z.string().optional(),
+  /**
+   *  @optional The ticket cannot be purchased if true
+   */
+  isNotBuyable: import_zod21.z.boolean().optional(),
+  /**
+   *  @optional If date is provided and in the past, ticket cannot be purchased
+   */
+  lastBuyableDate: import_zod21.z.coerce.date().optional()
 });
+var zMTTicket = extendZodObjectForMongoose(zTTicket);
 
 // src/interface/tournament/tConfig.ts
-var zTConfig = import_zod21.z.object({
+var zTConfig = import_zod22.z.object({
   /**
    * Location of the event
    */
-  location: import_zod21.z.string().optional(),
+  location: import_zod22.z.string().optional(),
   /**
    * URL of the tournament on the official website
    * Must be a valid URL link
    */
-  url: import_zod21.z.string(),
+  url: import_zod22.z.string(),
   /**
    * Full name of the tournament
    */
-  title: import_zod21.z.string(),
+  title: import_zod22.z.string(),
   /**
    * Abbreviated title of the tournament
    */
-  shortTitle: import_zod21.z.string(),
+  shortTitle: import_zod22.z.string(),
   /**
    * Tournament start date and time
    */
-  tStart: import_zod21.z.coerce.date(),
+  tStart: import_zod22.z.coerce.date(),
   /**
    * Tournament end date and time
    */
-  tEnd: import_zod21.z.coerce.date(),
+  tEnd: import_zod22.z.coerce.date(),
   /**
    * Short description for tournament card
    */
-  shortDescription: import_zod21.z.string(),
+  shortDescription: import_zod22.z.string(),
   /**
    * Full description
    */
-  description: import_zod21.z.string(),
+  description: import_zod22.z.string(),
   /**
    * Defines the tournament details table with 2 columns
    * typically Time and Event
@@ -546,80 +571,61 @@ var zTConfig = import_zod21.z.object({
   /**
    * List of ticket object IDs for this tournament
    */
-  tickets: import_zod21.z.array(import_zod21.z.instanceof(import_mongoose24.Types.ObjectId).or(import_zod21.z.string())),
+  tickets: import_zod22.z.array(import_zod22.z.instanceof(import_mongoose25.Types.ObjectId).or(import_zod22.z.string())),
   /**
    * If false, the tournament registration is closed
    */
-  canRegister: import_zod21.z.boolean(),
+  canRegister: import_zod22.z.boolean(),
   /**
    * If true, free form donation amounts are disabled.
    */
-  donationsDisabled: import_zod21.z.boolean().optional(),
+  donationsDisabled: import_zod22.z.boolean().optional(),
   /**
    * Defines URL, height, width of the image
    */
   image: zImageDef.optional()
 });
+var zTConfigResponse = zTConfig.extend({
+  tickets: import_zod22.z.array(zTTicket)
+});
 var zMTConfig = extendZodObjectForMongoose(zTConfig);
+var zMTConfigResponse = extendZodObjectForMongoose(zTConfigResponse);
 
 // src/interface/tournament/tReg.ts
-var import_mongoose27 = require("mongoose");
-var import_zod23 = require("zod");
+var import_mongoose28 = require("mongoose");
+var import_zod24 = require("zod");
 
 // src/interface/tournament/tTicketReg.ts
-var import_zod22 = require("zod");
-var import_mongoose26 = require("mongoose");
-var zTTicketReg = import_zod22.z.object({
-  ticket: import_zod22.z.instanceof(import_mongoose26.Types.ObjectId).or(import_zod22.z.string()),
+var import_zod23 = require("zod");
+var import_mongoose27 = require("mongoose");
+var zTTicketReg = import_zod23.z.object({
+  ticket: import_zod23.z.instanceof(import_mongoose27.Types.ObjectId).or(import_zod23.z.string()),
   /**
    * integer minimum 1, otherwise no ticket is being bought
    */
-  amount: import_zod22.z.number().int().min(1)
+  amount: import_zod23.z.number().int().min(1)
 });
 
 // src/interface/tournament/tReg.ts
-var zTReg = import_zod23.z.object({
-  agaId: import_zod23.z.string(),
-  tournamentId: import_zod23.z.instanceof(import_mongoose27.Types.ObjectId).or(import_zod23.z.string()),
-  tickets: import_zod23.z.array(zTTicketReg),
+var zTReg = import_zod24.z.object({
+  agaId: import_zod24.z.string(),
+  tournamentId: import_zod24.z.instanceof(import_mongoose28.Types.ObjectId).or(import_zod24.z.string()),
+  tickets: import_zod24.z.array(zTTicketReg),
   /**
    * @units CENTS - Donation in cents
    */
-  donation: import_zod23.z.number().optional(),
+  donation: import_zod24.z.number().optional(),
   /**
    * How the registration was created, namely through public endpoint or admin
    */
-  createMethod: import_zod23.z.string().optional(),
+  createMethod: import_zod24.z.string().optional(),
   /**
    * Mongoose ID of the admin that edited the registration
    */
-  edited: import_zod23.z.instanceof(import_mongoose27.Types.ObjectId).optional()
+  edited: import_zod24.z.instanceof(import_mongoose28.Types.ObjectId).optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMTReg = extendZodObjectForMongoose(zTReg);
 
-// src/interface/tournament/tTicket.ts
-var import_zod24 = require("zod");
-var zTTicket = import_zod24.z.object({
-  name: import_zod24.z.string(),
-  /**
-   * Price in cents
-   */
-  price: import_zod24.z.number(),
-  /**
-   * @optional description of the ticket
-   */
-  description: import_zod24.z.string().optional(),
-  /**
-   *  @optional The ticket cannot be purchased if true
-   */
-  isNotBuyable: import_zod24.z.boolean().optional(),
-  /**
-   *  @optional If date is provided and in the past, ticket cannot be purchased
-   */
-  lastBuyableDate: import_zod24.z.coerce.date().optional()
-});
-var zMTTicket = extendZodObjectForMongoose(zTTicket);
-
 // src/interface/user/goRank.ts
 var GoRank = /* @__PURE__ */ ((GoRank2) => {
   GoRank2["KYU1"] = "1k";
@@ -771,6 +777,7 @@ var zUserRoles = import_zod26.z.object({
   zMSemester,
   zMStudent,
   zMTConfig,
+  zMTConfigResponse,
   zMTReg,
   zMTTicket,
   zMTeacher,
@@ -783,6 +790,7 @@ var zUserRoles = import_zod26.z.object({
   zSemester,
   zStudent,
   zTConfig,
+  zTConfigResponse,
   zTReg,
   zTTicket,
   zTTicketReg,

package/index.mjs

@@ -134,24 +134,24 @@ var zDiscount = z7.object({
   amount: z7.number()
 });
 var zInvoiceItem = z7.object({
-  course: z7.instanceof(Types5.ObjectId).or(z7.string()),
+  course: z7.string().min(1),
   price: z7.number(),
   units: z7.number()
 });
 var zInvoicePackage = z7.object({
   student: z7.instanceof(Types5.ObjectId).or(z7.string()),
-  items: z7.array(zInvoiceItem)
+  items: z7.array(zInvoiceItem).min(1, "Package must contain at least one item")
 });
 var zInvoice = z7.object({
-  billTo: z7.string(),
-  packages: z7.array(zInvoicePackage),
+  billTo: z7.string().min(1, "The 'Bill To' field must not be empty"),
+  packages: z7.array(zInvoicePackage).min(1, "Invoice must include at least one package"),
   discounts: z7.array(zDiscount),
-  textbook: z7.number().int().min(1).optional(),
-  shipping: z7.number().int().min(1).optional(),
+  textbook: z7.number().int().min(0).optional(),
+  shipping: z7.number().int().min(0).optional(),
   paid: z7.nativeEnum(PaymentMethod).optional(),
   notes: z7.string().optional(),
   createdBy: z7.instanceof(Types5.ObjectId).or(z7.string()),
-  lastEditBy: z7.instanceof(Types5.ObjectId).optional()
+  lastEditBy: z7.instanceof(Types5.ObjectId).or(z7.string()).optional()
 });
 var zMInvoice = extendZodObjectForMongoose(zInvoice);
 
@@ -398,7 +398,7 @@ var zMSemester = extendZodObjectForMongoose(zSemester);
 
 // src/interface/tournament/tConfig.ts
 import { Types as Types12 } from "mongoose";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/interface/tournament/table.ts
 import { z as z20 } from "zod";
@@ -409,44 +409,67 @@ var zDetailsTable = z20.object({
 });
 var zScheduleTable = z20.object({
   fields: z20.array(z20.string()).length(2),
-  data: z20.map(z20.string(), zTable)
+  data: z20.record(z20.string(), zTable)
 });
 
+// src/interface/tournament/tTicket.ts
+import { z as z21 } from "zod";
+var zTTicket = z21.object({
+  name: z21.string(),
+  /**
+   * Price in cents
+   */
+  price: z21.number(),
+  /**
+   * @optional description of the ticket
+   */
+  description: z21.string().optional(),
+  /**
+   *  @optional The ticket cannot be purchased if true
+   */
+  isNotBuyable: z21.boolean().optional(),
+  /**
+   *  @optional If date is provided and in the past, ticket cannot be purchased
+   */
+  lastBuyableDate: z21.coerce.date().optional()
+});
+var zMTTicket = extendZodObjectForMongoose(zTTicket);
+
 // src/interface/tournament/tConfig.ts
-var zTConfig = z21.object({
+var zTConfig = z22.object({
   /**
    * Location of the event
    */
-  location: z21.string().optional(),
+  location: z22.string().optional(),
   /**
    * URL of the tournament on the official website
    * Must be a valid URL link
    */
-  url: z21.string(),
+  url: z22.string(),
   /**
    * Full name of the tournament
    */
-  title: z21.string(),
+  title: z22.string(),
   /**
    * Abbreviated title of the tournament
    */
-  shortTitle: z21.string(),
+  shortTitle: z22.string(),
   /**
    * Tournament start date and time
    */
-  tStart: z21.coerce.date(),
+  tStart: z22.coerce.date(),
   /**
    * Tournament end date and time
    */
-  tEnd: z21.coerce.date(),
+  tEnd: z22.coerce.date(),
   /**
    * Short description for tournament card
    */
-  shortDescription: z21.string(),
+  shortDescription: z22.string(),
   /**
    * Full description
    */
-  description: z21.string(),
+  description: z22.string(),
   /**
    * Defines the tournament details table with 2 columns
    * typically Time and Event
@@ -460,80 +483,61 @@ var zTConfig = z21.object({
   /**
    * List of ticket object IDs for this tournament
    */
-  tickets: z21.array(z21.instanceof(Types12.ObjectId).or(z21.string())),
+  tickets: z22.array(z22.instanceof(Types12.ObjectId).or(z22.string())),
   /**
    * If false, the tournament registration is closed
    */
-  canRegister: z21.boolean(),
+  canRegister: z22.boolean(),
   /**
    * If true, free form donation amounts are disabled.
    */
-  donationsDisabled: z21.boolean().optional(),
+  donationsDisabled: z22.boolean().optional(),
   /**
    * Defines URL, height, width of the image
    */
   image: zImageDef.optional()
 });
+var zTConfigResponse = zTConfig.extend({
+  tickets: z22.array(zTTicket)
+});
 var zMTConfig = extendZodObjectForMongoose(zTConfig);
+var zMTConfigResponse = extendZodObjectForMongoose(zTConfigResponse);
 
 // src/interface/tournament/tReg.ts
 import { Types as Types14 } from "mongoose";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/interface/tournament/tTicketReg.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 import { Types as Types13 } from "mongoose";
-var zTTicketReg = z22.object({
-  ticket: z22.instanceof(Types13.ObjectId).or(z22.string()),
+var zTTicketReg = z23.object({
+  ticket: z23.instanceof(Types13.ObjectId).or(z23.string()),
   /**
    * integer minimum 1, otherwise no ticket is being bought
    */
-  amount: z22.number().int().min(1)
+  amount: z23.number().int().min(1)
 });
 
 // src/interface/tournament/tReg.ts
-var zTReg = z23.object({
-  agaId: z23.string(),
-  tournamentId: z23.instanceof(Types14.ObjectId).or(z23.string()),
-  tickets: z23.array(zTTicketReg),
+var zTReg = z24.object({
+  agaId: z24.string(),
+  tournamentId: z24.instanceof(Types14.ObjectId).or(z24.string()),
+  tickets: z24.array(zTTicketReg),
   /**
    * @units CENTS - Donation in cents
    */
-  donation: z23.number().optional(),
+  donation: z24.number().optional(),
   /**
    * How the registration was created, namely through public endpoint or admin
    */
-  createMethod: z23.string().optional(),
+  createMethod: z24.string().optional(),
   /**
    * Mongoose ID of the admin that edited the registration
    */
-  edited: z23.instanceof(Types14.ObjectId).optional()
+  edited: z24.instanceof(Types14.ObjectId).optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMTReg = extendZodObjectForMongoose(zTReg);
 
-// src/interface/tournament/tTicket.ts
-import { z as z24 } from "zod";
-var zTTicket = z24.object({
-  name: z24.string(),
-  /**
-   * Price in cents
-   */
-  price: z24.number(),
-  /**
-   * @optional description of the ticket
-   */
-  description: z24.string().optional(),
-  /**
-   *  @optional The ticket cannot be purchased if true
-   */
-  isNotBuyable: z24.boolean().optional(),
-  /**
-   *  @optional If date is provided and in the past, ticket cannot be purchased
-   */
-  lastBuyableDate: z24.coerce.date().optional()
-});
-var zMTTicket = extendZodObjectForMongoose(zTTicket);
-
 // src/interface/user/goRank.ts
 var GoRank = /* @__PURE__ */ ((GoRank2) => {
   GoRank2["KYU1"] = "1k";
@@ -684,6 +688,7 @@ export {
   zMSemester,
   zMStudent,
   zMTConfig,
+  zMTConfigResponse,
   zMTReg,
   zMTTicket,
   zMTeacher,
@@ -696,6 +701,7 @@ export {
   zSemester,
   zStudent,
   zTConfig,
+  zTConfigResponse,
   zTReg,
   zTTicket,
   zTTicketReg,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyig/models",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "license": "MIT",
   "main": "index.js",
   "module": "index.mjs",