@updraft-solutions/mcrit-sdk 0.1.0

package/src/money/index.ts

@@ -0,0 +1,168 @@
+import Dinero from "dinero.js";
+import type { Dinero as DineroType } from "dinero.js";
+import { filter, head, sortBy } from "lodash-es";
+
+Dinero.globalLocale = "de-DE";
+
+export type NetGross = "net" | "gross";
+
+export interface PhpMoneyObject {
+  amount?: number;
+  currency?: string;
+  formatted?: string;
+}
+
+/**
+ * Permissive input shape for {@link parsePrice}. Mirrors the API
+ * `Price` resource but every field is optional so callers can pass
+ * partially-loaded data without casting.
+ */
+export interface PriceLike {
+  id?: number;
+  net_total?: PhpMoneyObject;
+  gross_total?: PhpMoneyObject;
+  tax_percentage?: number;
+  valid_from?: string;
+  input_value?: number;
+  net_gross?: NetGross;
+}
+
+/**
+ * Permissive input shape for {@link parseFee}. Mirrors the API `Fee`
+ * resource — accepts both the marketing-site shape and the SPA shape.
+ */
+export interface FeeLike {
+  id?: number;
+  price?: PriceLike | null;
+  prices?: PriceLike[] | null;
+  title?: string;
+  ident?: string;
+  [key: string]: unknown;
+}
+
+export interface ParsedPrice extends Omit<PriceLike, "net_total" | "gross_total"> {
+  net_total: DineroType;
+  gross_total: DineroType;
+}
+
+export interface ParsedFee {
+  currentPrice(netGross?: NetGross | null): DineroType | ParsedPrice | null;
+  upcomingPrice(netGross?: NetGross | null): DineroType | ParsedPrice | null;
+}
+
+interface MoneyShape {
+  amount?: number;
+  value?: { amount?: number };
+}
+
+type MoneyInput = number | string | MoneyShape | PhpMoneyObject | null | undefined;
+
+export function money(amount: MoneyInput): DineroType {
+  try {
+    let parsed: unknown = amount;
+
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed as MoneyShape;
+      if (obj.value && typeof obj.value === "object" && typeof obj.value.amount !== "undefined") {
+        parsed = obj.value.amount;
+      } else if (typeof obj.amount !== "undefined") {
+        parsed = obj.amount;
+      }
+    }
+
+    const int = parseInt(String(parsed ?? "0"), 10);
+    if (Number.isNaN(int)) {
+      throw new Error("Invalid amount");
+    }
+
+    return Dinero({ amount: int, currency: "EUR" });
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error("[mcrit-sdk/money] failed to parse amount:", amount, e);
+    return Dinero({ amount: 0, currency: "EUR" });
+  }
+}
+
+export function moneyFormatted(dinero: DineroType | null | undefined): string {
+  return dinero ? dinero.toFormat() : "";
+}
+
+export function parsePrice(price: PriceLike | null | undefined): ParsedPrice | null {
+  if (!price) {
+    return null;
+  }
+  return {
+    ...price,
+    net_total: money(price.net_total?.amount ?? 0),
+    gross_total: money(price.gross_total?.amount ?? 0),
+  };
+}
+
+function priceFor(parsed: ParsedPrice, netGross: NetGross | null): DineroType | ParsedPrice {
+  if (netGross === "net") {
+    return parsed.net_total;
+  }
+  if (netGross === "gross") {
+    return parsed.gross_total;
+  }
+  return parsed;
+}
+
+export function parseFee(fee: FeeLike | null | undefined): ParsedFee | null {
+  if (!fee) {
+    return null;
+  }
+  return {
+    currentPrice(netGross: NetGross | null = null) {
+      const parsed = parsePrice(fee.price ?? null);
+      return parsed ? priceFor(parsed, netGross) : null;
+    },
+
+    upcomingPrice(netGross: NetGross | null = null) {
+      const now = Date.now();
+      const upcoming = head(
+        sortBy(
+          filter(fee.prices ?? [], (p) => {
+            const t = p.valid_from ? Date.parse(p.valid_from) : NaN;
+            return Number.isFinite(t) && t > now;
+          }),
+          (p) => Date.parse(p.valid_from ?? ""),
+        ),
+      );
+      if (!upcoming) {
+        return null;
+      }
+      const parsed = parsePrice(upcoming);
+      return parsed ? priceFor(parsed, netGross) : null;
+    },
+  };
+}
+
+export function displayFee(
+  fee: FeeLike | null | undefined,
+  netGross: NetGross = "gross",
+  fallback = "Keine Gebühr hinterlegt",
+): string {
+  const current = parseFee(fee)?.currentPrice(netGross);
+  if (current && "toFormat" in current) {
+    return current.toFormat();
+  }
+  return fallback;
+}
+
+/**
+ * Strict-numeric alias of {@link money} for callers that already have
+ * a clean integer cents amount. Equivalent to `Dinero({amount, currency: "EUR"})`.
+ */
+export function fromCents(amount: number): DineroType {
+  return Dinero({ amount, currency: "EUR" });
+}
+
+/**
+ * Formats an integer cents amount as a German Euro string
+ * (`"€ 1.234,56"`). Tolerates null/undefined/string input.
+ */
+export function formatToEuroString(amount: number | string | null | undefined): string {
+  const cents = parseInt(String(amount ?? "0"), 10);
+  return `€ ${fromCents(Number.isNaN(cents) ? 0 : cents).setLocale("de-DE").toFormat("0,0.00")}`;
+}

package/src/pagination/index.ts

@@ -0,0 +1,27 @@
+export interface PaginationOptions {
+  page: number;
+  itemsPerPage: number;
+}
+
+export interface PaginationMeta {
+  start: number;
+  end: number;
+  total: number;
+}
+
+/**
+ * Compute the `start`/`end`/`total` window for a paginated UI footer.
+ * Returns `start: 0` when `total` is zero so empty states render cleanly.
+ */
+export function paginationMeta(
+  options: PaginationOptions,
+  total: number,
+): PaginationMeta {
+  const start = (options.page - 1) * options.itemsPerPage + 1;
+  const end = Math.min(options.page * options.itemsPerPage, total);
+  return {
+    start: total === 0 ? 0 : start,
+    end,
+    total,
+  };
+}

package/src/schemas/common.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+// Shared helpers
+export const zNullableBool = z.boolean().nullable().optional();
+export const zNetGross = z.enum(["net", "gross"]).optional();
+export const zContactDTO = z.object({
+  name: z.string().optional(),
+  email: z.string().email().optional(),
+  phone: z.string().optional(),
+});
+export const zPhpMoneyObject = z.object({
+  amount: z.number(),
+  currency: z.string(),
+  formatted: z.string(),
+});
+
+// Contact attribute schema (from Models/common.ts)
+export const contactAttributeSchema = z.object({
+  name: z.string().optional(),
+  email: z.string().optional(),
+  phone: z.string().optional(),
+  company: z.string().optional(),
+  fax: z.string().optional(),
+});
+
+// Base model
+export const BaseModel = z.object({
+  type: z.string(),
+  id: z.number(),
+  created_at: z.string(),
+  updated_at: z.string(),
+});
+
+// Media
+export const mediaSchema = z.object({
+  type: z.literal("media"),
+  id: z.number(),
+  description: z.string().optional(),
+  collection_name: z.string().optional(),
+  conversions: z.record(z.string().url()).optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+  url: z.string().optional(),
+  mime_type: z.string().optional(),
+  file_name: z.string().optional(),
+  size: z.number().optional(),
+});
+
+export const mediaCollection = z
+  .object({
+    avatar: mediaSchema.nullable().optional(),
+    header: mediaSchema.nullable().optional(),
+    images: z.array(mediaSchema).nullable().optional(),
+    documents: z.array(mediaSchema).nullable().optional(),
+  })
+  .nullable()
+  .optional();
+
+// User & Company
+export const userSchema = z.object({
+  type: z.literal("user"),
+  id: z.number(),
+  name: z.string(),
+  email: z.string().optional(),
+  mobile: z.string().optional(),
+});
+
+export const companySchema = z.object({
+  type: z.literal("company"),
+  id: z.number(),
+  name: z.string(),
+  media: mediaCollection,
+});

package/src/schemas/faq.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+
+// FAQ Status enum - matches backend constants
+export enum FaqStatus {
+  PENDING = "pending",
+  APPROVED = "approved",
+  REJECTED = "rejected",
+}
+
+// User schema for submitter/reviewer
+const UserBasicSchema = z
+  .object({
+    id: z.number(),
+    name: z.string(),
+    email: z.string().email(),
+  })
+  .nullable();
+
+// FAQ schema - matches backend FaqResource with user submission support
+export const FaqSchema = z.object({
+  type: z.literal("faq"),
+  id: z.number(),
+  company_id: z.number().nullable(),
+  faqable_type: z.string().nullable(),
+  faqable_id: z.number().nullable(),
+  category: z.string(),
+  subcategory: z.string().nullable(),
+  question: z.string(),
+  answer: z.string().nullable(),
+  order: z.number(),
+  is_active: z.boolean(),
+  status: z.enum(["pending", "approved", "rejected"]),
+  submitted_by: z.number().nullable(),
+  reviewed_by: z.number().nullable(),
+  reviewed_at: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string(),
+  submitter: UserBasicSchema.optional(),
+  reviewer: UserBasicSchema.optional(),
+  is_pending: z.boolean().optional(),
+  is_user_submitted: z.boolean().optional(),
+  can: z
+    .object({
+      view: z.boolean().optional(),
+      update: z.boolean().optional(),
+      delete: z.boolean().optional(),
+      review: z.boolean().optional(),
+      submit: z.boolean().optional(),
+    })
+    .optional(),
+});
+
+// Type exports
+export type Faq = z.infer<typeof FaqSchema>;
+
+// Input types for API calls
+export interface CreateFaqInput {
+  category: string;
+  subcategory?: string | null;
+  question: string;
+  answer: string;
+  order?: number;
+  is_active?: boolean;
+}
+
+export interface UpdateFaqInput {
+  category?: string;
+  subcategory?: string | null;
+  question?: string;
+  answer?: string;
+  order?: number;
+  is_active?: boolean;
+}
+
+// User submission schema - matches SubmitFaqQuestionRequest
+export const SubmitFaqQuestionSchema = z.object({
+  category: z.string().min(1, "Category is required"),
+  subcategory: z.string().nullable().optional(),
+  question: z.string().min(10, "Question must be at least 10 characters"),
+});
+
+export type SubmitFaqQuestionInput = z.infer<typeof SubmitFaqQuestionSchema>;
+
+// Review schema - matches ReviewFaqRequest
+export const ReviewFaqSchema = z.object({
+  status: z.enum(["pending", "approved", "rejected"]),
+  answer: z.string().optional(),
+  category: z.string().optional(),
+  subcategory: z.string().nullable().optional(),
+  order: z.number().optional(),
+  is_active: z.boolean().optional(),
+});
+
+export type ReviewFaqInput = z.infer<typeof ReviewFaqSchema>;

package/src/schemas/fee.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const FeeSchema = z.object({
+  id: z.number(),
+  type: z.literal("fee").optional(),
+  company_id: z.number(),
+  provider: z.string().nullable().optional(),
+  category: z.string(),
+  subcategory: z.string().nullable().optional(),
+  title: z.string(),
+  internal_title: z.string().nullable().optional(),
+  display_title: z.string().optional(),
+  relation: z
+    .array(z.enum(["booking", "flightlog", "invoice", "instructor"]))
+    .nullable()
+    .optional(),
+  payment_per: z
+    .enum(["perSession", "perFlight", "perBooking", "perHour"])
+    .nullable()
+    .optional(),
+  price: z.any().optional(),
+  prices: z.array(z.any()).optional(),
+  can: z
+    .object({
+      update: z.boolean().optional(),
+      delete: z.boolean().optional(),
+    })
+    .optional(),
+});
+
+export const FeeCategoryOptionsSchema = z.object({
+  categories: z.array(z.string()),
+  subcategories: z.record(z.string(), z.array(z.string())),
+});
+
+export type Fee = z.infer<typeof FeeSchema>;
+export type FeeCategoryOptions = z.infer<typeof FeeCategoryOptionsSchema>;

package/src/schemas/index.ts

@@ -0,0 +1,6 @@
+export * from "./common";
+export * from "./models";
+export * from "./faq";
+export * from "./fee";
+export * from "./safety-report";
+export * from "./report";