@marmot-systems/common 2.0.90 → 2.0.92

package/dist/index.cjs

@@ -31,7 +31,6 @@ __export(index_exports, {
   PAYMENT_METHOD: () => PAYMENT_METHOD,
   POS_INVOICE_TYPE: () => POS_INVOICE_TYPE,
   PaymentFormSchema: () => PaymentFormSchema,
-  RegisterFormSchema: () => RegisterFormSchema,
   USER_ROLES: () => USER_ROLES,
   YmdDateSchema: () => YmdDateSchema,
   addDaysLocalYmd: () => addDaysLocalYmd,
@@ -48,6 +47,8 @@ __export(index_exports, {
   makeInvoiceSchemas: () => makeInvoiceSchemas,
   makePosSchemas: () => makePosSchemas,
   makeProductSchemas: () => makeProductSchemas,
+  makeRegisterSchemas: () => makeRegisterSchemas,
+  makeUsersSchemas: () => makeUsersSchemas,
   mapInvoiceProducts: () => mapInvoiceProducts,
   normalizeSpaces: () => normalizeSpaces,
   removeAllWhitespace: () => removeAllWhitespace,
@@ -177,36 +178,37 @@ var COMPANY_LANGUAGES = ["es", "en"];
 var iso_country_code = import_zod4.z.enum(ISO_COUNTRY_CODES, {
   error: "Country code not supported."
 });
-var RegisterFormSchema = import_zod4.z.strictObject({
-  companyData: import_zod4.z.strictObject({
-    company_name: import_zod4.z.string().transform(normalizeSpaces).pipe(
-      import_zod4.z.string().min(1, "Company name is required").max(50, "Company name must be at most 50 characters.")
-    ),
-    company_address: import_zod4.z.string().transform(normalizeSpaces).pipe(
-      import_zod4.z.string().min(1, "Company address is required").max(100, "Company address must be at most 100 characters.")
-    ),
-    company_phone_number: import_zod4.z.string().transform(removeAllWhitespace).transform(removeDashesAndPlusSign).refine((s) => /^\d{4,15}$/.test(s), {
-      error: "Phone number required and must be from 4 to 15 digits."
+function makeRegisterSchemas(t) {
+  const RegisterFormSchema = import_zod4.z.strictObject({
+    companyData: import_zod4.z.strictObject({
+      company_name: import_zod4.z.string().transform(normalizeSpaces).pipe(
+        import_zod4.z.string().min(1, t("company_name_required")).max(50, t("company_name_max"))
+      ),
+      company_address: import_zod4.z.string().transform(normalizeSpaces).pipe(
+        import_zod4.z.string().min(1, t("company_address_required")).max(100, t("company_address_max"))
+      ),
+      company_phone_number: import_zod4.z.string().transform(removeAllWhitespace).transform(removeDashesAndPlusSign).refine((s) => /^\d{4,15}$/.test(s), {
+        error: t("phone_number_required")
+      }),
+      iso_country_code: import_zod4.z.string({ error: t("country_required") }).transform(removeAllWhitespace).transform((s) => s.toUpperCase()).pipe(iso_country_code)
     }),
-    iso_country_code: import_zod4.z.string({ error: "Please select a country." }).transform(removeAllWhitespace).transform((s) => s.toUpperCase()).pipe(iso_country_code)
-  }),
-  adminUserData: import_zod4.z.strictObject({
-    user_first_name: import_zod4.z.string().transform(normalizeSpaces).pipe(
-      import_zod4.z.string().min(1, "First name is required").max(50, "First name must be at most 50 characters.")
-    ),
-    user_last_name: import_zod4.z.string().transform(normalizeSpaces).pipe(
-      import_zod4.z.string().min(1, "Last name is required").max(50, "Last name must be at most 50 characters.")
-    ),
-    user_email: import_zod4.z.string().transform(removeAllWhitespace).pipe(
-      import_zod4.z.email().max(254, "Customer email must be at most 254 characters.").transform((email) => email.toLowerCase())
-    ),
-    password: import_zod4.z.string().min(8, "Password must be at least 8 characters").max(25, "Password must be at most 25 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/\d/, "Password must contain at least one number").regex(
-      /[@$!%*?&#^_+=-]/,
-      "Password must contain at least one special character"
-    ).regex(/^\S*$/, "Password cannot contain spaces or other whitespace.")
-  })
-});
-var CompanyFormSchema = RegisterFormSchema.shape.companyData.safeExtend({
+    adminUserData: import_zod4.z.strictObject({
+      user_first_name: import_zod4.z.string().transform(normalizeSpaces).pipe(
+        import_zod4.z.string().min(1, t("first_name_required")).max(50, t("first_name_max"))
+      ),
+      user_last_name: import_zod4.z.string().transform(normalizeSpaces).pipe(
+        import_zod4.z.string().min(1, t("lsat_name_required")).max(50, t("last_name_max"))
+      ),
+      user_email: import_zod4.z.string().transform(removeAllWhitespace).pipe(
+        import_zod4.z.email({ error: t("email_required") }).max(254, t("email_max")).transform((email) => email.toLowerCase())
+      ),
+      password: import_zod4.z.string().min(8, t("pass_min")).max(25, t("pass_max")).regex(/[A-Z]/, t("pass_uppercase")).regex(/[a-z]/, t("pass_lowercase")).regex(/\d/, t("pass_one_number")).regex(/[@$!%*?&#^_+=-]/, t("pass_special_character")).regex(/^\S*$/, t("pass_no_whitespace"))
+    })
+  });
+  return { RegisterFormSchema };
+}
+var schemas = makeRegisterSchemas((k) => k);
+var CompanyFormSchema = schemas.RegisterFormSchema.shape.companyData.safeExtend({
   company_email: import_zod4.z.string().transform(removeAllWhitespace).pipe(
     import_zod4.z.email("Invalid company email.").max(254, "Company email must be at most 254 characters.").transform((email) => email.toLowerCase())
   ),
@@ -216,50 +218,71 @@ var CompanyFormSchema = RegisterFormSchema.shape.companyData.safeExtend({
   })
 });
 
-// src/domains/customers/customer_schemas.ts
+// src/domains/users/users_schemas.ts
 var import_zod5 = require("zod");
+function makeUsersSchemas(t) {
+  const CreateUserSchema = import_zod5.z.object({
+    firstName: import_zod5.z.string().transform(normalizeSpaces).pipe(
+      import_zod5.z.string().min(1, t("first_name_required")).max(50, t("first_name_max"))
+    ),
+    lastName: import_zod5.z.string().transform(normalizeSpaces).pipe(
+      import_zod5.z.string().min(1, t("lsat_name_required")).max(50, t("last_name_max"))
+    ),
+    email: import_zod5.z.string().transform(removeAllWhitespace).pipe(
+      import_zod5.z.email({ error: t("email_required") }).max(254, t("email_max")).transform((email) => email.toLowerCase())
+    ),
+    password: import_zod5.z.string().min(8, t("pass_min")).max(25, t("pass_max")).regex(/[A-Z]/, t("pass_uppercase")).regex(/[a-z]/, t("pass_lowercase")).regex(/\d/, t("pass_one_number")).regex(/[@$!%*?&#^_+=-]/, t("pass_special_character")).regex(/^\S*$/, t("pass_no_whitespace")),
+    accountType: import_zod5.z.enum(["admin", "driver"], {
+      error: t("account_type")
+    })
+  });
+  return { CreateUserSchema };
+}
+
+// src/domains/customers/customer_schemas.ts
+var import_zod6 = require("zod");
 function makeCustomerSchemas(t) {
-  const CustomerFormSchema = import_zod5.z.strictObject({
-    customer_name: import_zod5.z.string().transform(normalizeSpaces).pipe(
-      import_zod5.z.string().min(1, t("customer_name_required")).max(50, t("customer_name_max"))
+  const CustomerFormSchema = import_zod6.z.strictObject({
+    customer_name: import_zod6.z.string().transform(normalizeSpaces).pipe(
+      import_zod6.z.string().min(1, t("customer_name_required")).max(50, t("customer_name_max"))
     ),
-    customer_address: import_zod5.z.string().transform(normalizeSpaces).pipe(import_zod5.z.string().max(100, t("customer_address_max"))).transform(transformEmptyStringToUndefined).optional(),
-    customer_phone_number: import_zod5.z.string().transform(removeAllWhitespace).transform(removeDashesAndPlusSign).refine((s) => s === "" || /^\d{4,15}$/.test(s), {
+    customer_address: import_zod6.z.string().transform(normalizeSpaces).pipe(import_zod6.z.string().max(100, t("customer_address_max"))).transform(transformEmptyStringToUndefined).optional(),
+    customer_phone_number: import_zod6.z.string().transform(removeAllWhitespace).transform(removeDashesAndPlusSign).refine((s) => s === "" || /^\d{4,15}$/.test(s), {
       error: t("customer_phone_number")
     }).transform(transformEmptyStringToUndefined).optional(),
-    customer_email_address: import_zod5.z.string().transform(removeAllWhitespace).transform(transformEmptyStringToUndefined).pipe(
-      import_zod5.z.email().max(254, t("customer_email_max")).transform((email) => email.toLowerCase()).optional()
+    customer_email_address: import_zod6.z.string().transform(removeAllWhitespace).transform(transformEmptyStringToUndefined).pipe(
+      import_zod6.z.email().max(254, t("customer_email_max")).transform((email) => email.toLowerCase()).optional()
     ).optional()
   });
   return { CustomerFormSchema };
 }
 
 // src/domains/products/product_schemas.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 function makeProductSchemas(t) {
-  const ProductFormSchema = import_zod6.z.strictObject({
-    product_name: import_zod6.z.string().transform(normalizeSpaces).pipe(
-      import_zod6.z.string().min(1, t("product_name_required")).max(50, t("product_name_max"))
+  const ProductFormSchema = import_zod7.z.strictObject({
+    product_name: import_zod7.z.string().transform(normalizeSpaces).pipe(
+      import_zod7.z.string().min(1, t("product_name_required")).max(50, t("product_name_max"))
     ),
-    product_description: import_zod6.z.string().transform(normalizeSpaces).pipe(import_zod6.z.string().max(100, t("product_descr_max"))).transform(transformEmptyStringToUndefined).optional(),
-    product_sku: import_zod6.z.string().transform(normalizeSpaces).pipe(import_zod6.z.string().max(30, t("product_sku_max"))).transform(transformEmptyStringToUndefined).optional(),
-    product_upc: import_zod6.z.string().transform(removeAllWhitespace).refine((s) => s === "" || /^\d{12}$/.test(s), {
+    product_description: import_zod7.z.string().transform(normalizeSpaces).pipe(import_zod7.z.string().max(100, t("product_descr_max"))).transform(transformEmptyStringToUndefined).optional(),
+    product_sku: import_zod7.z.string().transform(normalizeSpaces).pipe(import_zod7.z.string().max(30, t("product_sku_max"))).transform(transformEmptyStringToUndefined).optional(),
+    product_upc: import_zod7.z.string().transform(removeAllWhitespace).refine((s) => s === "" || /^\d{12}$/.test(s), {
       error: t("product_upc_test")
     }).transform(transformEmptyStringToUndefined).optional(),
-    country_tax_rule_id: import_zod6.z.number().optional(),
-    product_gtin_14: import_zod6.z.string().transform(removeAllWhitespace).refine((s) => s === "" || /^\d{14}$/.test(s), {
+    country_tax_rule_id: import_zod7.z.number().optional(),
+    product_gtin_14: import_zod7.z.string().transform(removeAllWhitespace).refine((s) => s === "" || /^\d{14}$/.test(s), {
       error: "GTIN14 must be exactly 14 digits"
     }).transform(transformEmptyStringToUndefined).optional(),
-    product_type: import_zod6.z.enum(["unit", "weight", "case"], {
+    product_type: import_zod7.z.enum(["unit", "weight", "case"], {
       error: t("product_type_validation")
     }),
-    weight_unit: import_zod6.z.preprocess(
+    weight_unit: import_zod7.z.preprocess(
       (v) => {
         if (v === "") return void 0;
         if (typeof v === "string") return v.trim().toLowerCase();
         return v;
       },
-      import_zod6.z.enum(["kg", "lb", "g", "oz"]).optional()
+      import_zod7.z.enum(["kg", "lb", "g", "oz"]).optional()
     ),
     price: handleZodCurrency(0, 99999.99, t),
     cost: handleZodCurrency(0, 99999.99, t)
@@ -283,7 +306,7 @@ function makeProductSchemas(t) {
 }
 
 // src/domains/invoices/invoices_schemas.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/domains/invoices/invoices_types.ts
 var INVOICE_TYPE = [
@@ -296,19 +319,19 @@ var INVOICE_STATUS = ["finalized", "voided"];
 var CREDIT_TYPE = ["dump", "return"];
 
 // src/domains/invoices/invoices_schemas.ts
-var YmdDateSchema = import_zod7.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use YYYY-MM-DD");
+var YmdDateSchema = import_zod8.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use YYYY-MM-DD");
 function makeInvoiceSchemas(t) {
-  const YmdDateSchema2 = import_zod7.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use YYYY-MM-DD");
-  const BaseInvoice = import_zod7.z.object({
-    invoice_type: import_zod7.z.enum(INVOICE_TYPE, {
+  const YmdDateSchema2 = import_zod8.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use YYYY-MM-DD");
+  const BaseInvoice = import_zod8.z.object({
+    invoice_type: import_zod8.z.enum(INVOICE_TYPE, {
       error: t("invoice_type_not_found")
     }),
     invoice_date: YmdDateSchema2,
     due_date: YmdDateSchema2,
-    tax_rate: import_zod7.z.number().default(0),
-    tax_amount: import_zod7.z.number().default(0),
-    warehouse_id: import_zod7.z.uuid().optional(),
-    invoice_status: import_zod7.z.enum(INVOICE_STATUS).default("finalized")
+    tax_rate: import_zod8.z.number().default(0),
+    tax_amount: import_zod8.z.number().default(0),
+    warehouse_id: import_zod8.z.uuid().optional(),
+    invoice_status: import_zod8.z.enum(INVOICE_STATUS).default("finalized")
   }).superRefine(({ invoice_date, due_date }, ctx) => {
     if (due_date < invoice_date) {
       ctx.addIssue({
@@ -318,63 +341,63 @@ function makeInvoiceSchemas(t) {
       });
     }
   });
-  const LineItemBase = import_zod7.z.object({
-    invoice_id: import_zod7.z.uuid().optional(),
-    product_id: import_zod7.z.uuid({
+  const LineItemBase = import_zod8.z.object({
+    invoice_id: import_zod8.z.uuid().optional(),
+    product_id: import_zod8.z.uuid({
       error: t("select_product")
     }),
-    product_name: import_zod7.z.string().optional(),
-    product_description: import_zod7.z.string().optional(),
-    product_type: import_zod7.z.enum(["unit", "weight", "case"]).optional(),
-    product_upc: import_zod7.z.string().optional(),
-    weight_unit: import_zod7.z.enum(["kg", "lb", "g", "oz"]).optional(),
+    product_name: import_zod8.z.string().optional(),
+    product_description: import_zod8.z.string().optional(),
+    product_type: import_zod8.z.enum(["unit", "weight", "case"]).optional(),
+    product_upc: import_zod8.z.string().optional(),
+    weight_unit: import_zod8.z.enum(["kg", "lb", "g", "oz"]).optional(),
     quantity: handleZodCurrency(0.01, 99999.99, t),
-    country_tax_rule_id: import_zod7.z.number().optional(),
-    tax_percentage: import_zod7.z.number().optional()
+    country_tax_rule_id: import_zod8.z.number().optional(),
+    tax_percentage: import_zod8.z.number().optional()
   });
   const SalesItem = LineItemBase.safeExtend({
     price: handleZodCurrency(0, 99999.99, t),
-    credit_type: import_zod7.z.undefined()
+    credit_type: import_zod8.z.undefined()
   });
   const CreditItem = LineItemBase.safeExtend({
     price: handleZodCurrency(0, 99999.99, t),
-    credit_type: import_zod7.z.enum(CREDIT_TYPE, {
+    credit_type: import_zod8.z.enum(CREDIT_TYPE, {
       error: t("select_credit_type")
     })
   });
   const PurchaseItem = LineItemBase.safeExtend({
     price: handleZodCurrency(0, 99999.99, t),
-    credit_type: import_zod7.z.undefined()
+    credit_type: import_zod8.z.undefined()
   });
   const SalesInvoiceSchema = BaseInvoice.safeExtend({
-    invoice_type: import_zod7.z.literal("sales"),
-    party_id: import_zod7.z.uuid({
+    invoice_type: import_zod8.z.literal("sales"),
+    party_id: import_zod8.z.uuid({
       error: t("select_customer")
     }),
-    invoice_items: import_zod7.z.array(SalesItem).min(1, t("add_one_invoice_item"))
+    invoice_items: import_zod8.z.array(SalesItem).min(1, t("add_one_invoice_item"))
   });
   const CreditInvoiceSchema = BaseInvoice.safeExtend({
-    invoice_type: import_zod7.z.literal("credit"),
-    party_id: import_zod7.z.uuid({
+    invoice_type: import_zod8.z.literal("credit"),
+    party_id: import_zod8.z.uuid({
       error: t("select_customer")
     }),
-    invoice_items: import_zod7.z.array(CreditItem).min(1, t("add_one_invoice_item"))
+    invoice_items: import_zod8.z.array(CreditItem).min(1, t("add_one_invoice_item"))
   });
   const PurchaseInvoiceSchema = BaseInvoice.safeExtend({
-    invoice_type: import_zod7.z.literal("purchase"),
-    party_id: import_zod7.z.uuid({
+    invoice_type: import_zod8.z.literal("purchase"),
+    party_id: import_zod8.z.uuid({
       error: t("select_vendor")
     }),
-    invoice_items: import_zod7.z.array(PurchaseItem).min(1, t("add_one_invoice_item"))
+    invoice_items: import_zod8.z.array(PurchaseItem).min(1, t("add_one_invoice_item"))
   });
   const SalesOrderSchema = BaseInvoice.safeExtend({
-    invoice_type: import_zod7.z.literal("sales_order"),
-    party_id: import_zod7.z.uuid({
+    invoice_type: import_zod8.z.literal("sales_order"),
+    party_id: import_zod8.z.uuid({
       error: t("select_customer")
     }),
-    invoice_items: import_zod7.z.array(SalesItem).min(1, t("add_one_invoice_item"))
+    invoice_items: import_zod8.z.array(SalesItem).min(1, t("add_one_invoice_item"))
   });
-  const AnyInvoiceSchema = import_zod7.z.discriminatedUnion("invoice_type", [
+  const AnyInvoiceSchema = import_zod8.z.discriminatedUnion("invoice_type", [
     SalesInvoiceSchema,
     PurchaseInvoiceSchema,
     CreditInvoiceSchema,
@@ -412,14 +435,14 @@ function mapInvoiceProducts(row) {
 }
 
 // src/domains/credit_applications/credit_applications_schemas.ts
-var import_zod8 = require("zod");
-var CreditApplicationSchema = import_zod8.z.strictObject({
-  credit_invoice_id: import_zod8.z.uuid({ error: "Select a credit" }),
+var import_zod9 = require("zod");
+var CreditApplicationSchema = import_zod9.z.strictObject({
+  credit_invoice_id: import_zod9.z.uuid({ error: "Select a credit" }),
   applied_amount: handleZodCurrency(0.01, 999999.99)
 });
 
 // src/domains/payments/payments_schemas.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/domains/payments/payments_types.ts
 var PAYMENT_METHOD = [
@@ -430,12 +453,12 @@ var PAYMENT_METHOD = [
 ];
 
 // src/domains/payments/payments_schemas.ts
-var PaymentFormSchema = import_zod9.z.strictObject({
-  payment_method: import_zod9.z.enum(PAYMENT_METHOD, {
+var PaymentFormSchema = import_zod10.z.strictObject({
+  payment_method: import_zod10.z.enum(PAYMENT_METHOD, {
     error: "Payment method is required."
   }),
-  check_number: import_zod9.z.string().transform(normalizeSpaces).pipe(
-    import_zod9.z.string().max(50, "Payment check number must be at most 50 characters.")
+  check_number: import_zod10.z.string().transform(normalizeSpaces).pipe(
+    import_zod10.z.string().max(50, "Payment check number must be at most 50 characters.")
   ).transform(transformEmptyStringToUndefined).optional(),
   payment_amount: handleZodCurrency(0.01, 999999.99)
 });
@@ -497,7 +520,7 @@ var getErrorMessage = (err) => {
 };
 
 // src/domains/point_of_sales/point_of_sales_schemas.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/domains/point_of_sales/point_of_sales_types.ts
 var POS_INVOICE_TYPE = ["sales", "credit"];
@@ -505,14 +528,14 @@ var POS_INVOICE_TYPE = ["sales", "credit"];
 // src/domains/point_of_sales/point_of_sales_schemas.ts
 function makePosSchemas(t) {
   const HN_INVOICE_REGEX = /^\d{3}-\d{3}-\d{2}-\d{8}$/;
-  const InvoiceNumberSchema = import_zod10.z.string().transform(removeAllWhitespace).pipe(
-    import_zod10.z.string().min(19, t("must_be_in_format")).max(19, t("must_be_in_format")).regex(HN_INVOICE_REGEX, {
+  const InvoiceNumberSchema = import_zod11.z.string().transform(removeAllWhitespace).pipe(
+    import_zod11.z.string().min(19, t("must_be_in_format")).max(19, t("must_be_in_format")).regex(HN_INVOICE_REGEX, {
       error: t("must_be_in_format")
     })
   );
-  const PointOfSalesSchema = import_zod10.z.strictObject({
-    cai: import_zod10.z.string().transform(removeAllWhitespace).pipe(import_zod10.z.string().min(1, t("cai_is_required")).max(50, t("cai_max"))),
-    pos_invoice_type: import_zod10.z.enum(POS_INVOICE_TYPE, t("select_invoice_type")),
+  const PointOfSalesSchema = import_zod11.z.strictObject({
+    cai: import_zod11.z.string().transform(removeAllWhitespace).pipe(import_zod11.z.string().min(1, t("cai_is_required")).max(50, t("cai_max"))),
+    pos_invoice_type: import_zod11.z.enum(POS_INVOICE_TYPE, t("select_invoice_type")),
     invoice_number_start_range: InvoiceNumberSchema,
     invoice_number_end_range: InvoiceNumberSchema,
     next_invoice_number: InvoiceNumberSchema,
@@ -581,7 +604,6 @@ function makePosSchemas(t) {
   PAYMENT_METHOD,
   POS_INVOICE_TYPE,
   PaymentFormSchema,
-  RegisterFormSchema,
   USER_ROLES,
   YmdDateSchema,
   addDaysLocalYmd,
@@ -598,6 +620,8 @@ function makePosSchemas(t) {
   makeInvoiceSchemas,
   makePosSchemas,
   makeProductSchemas,
+  makeRegisterSchemas,
+  makeUsersSchemas,
   mapInvoiceProducts,
   normalizeSpaces,
   removeAllWhitespace,