@updraft-solutions/mcrit-sdk 0.4.0 → 0.6.0

package/src/schemas/newsletter.ts

@@ -0,0 +1,362 @@
+import { z } from "zod";
+
+/*
+|------------------------------------------------------------------------
+| Block schemas
+|------------------------------------------------------------------------
+|
+| v1 supports heading / paragraph / button / divider. Paragraph content
+| is stored as TipTap JSON on `doc` so variable tokens survive
+| sanitisation. The server converts `variable` nodes to `{{name}}` at
+| render time.
+*/
+
+export enum NewsletterBlockType {
+  Heading = "heading",
+  Paragraph = "paragraph",
+  Button = "button",
+  Divider = "divider",
+}
+
+export const TipTapNodeSchema: z.ZodType<TipTapNode> = z.lazy(() =>
+  z.object({
+    type: z.string(),
+    attrs: z.record(z.any()).optional(),
+    content: z.array(TipTapNodeSchema).optional(),
+    marks: z.array(z.record(z.any())).optional(),
+    text: z.string().optional(),
+  }),
+);
+
+export interface TipTapNode {
+  type: string;
+  attrs?: Record<string, unknown>;
+  content?: TipTapNode[];
+  marks?: Array<Record<string, unknown>>;
+  text?: string;
+}
+
+const Align = z.enum(["left", "center", "right"]).optional();
+
+export const HeadingBlockSchema = z.object({
+  key: z.string(),
+  type: z.literal(NewsletterBlockType.Heading),
+  level: z.number().int().min(1).max(3).default(1),
+  text: z.string(),
+  align: Align,
+});
+
+export const ParagraphBlockSchema = z.object({
+  key: z.string(),
+  type: z.literal(NewsletterBlockType.Paragraph),
+  doc: TipTapNodeSchema,
+  align: Align,
+});
+
+export const ButtonBlockSchema = z.object({
+  key: z.string(),
+  type: z.literal(NewsletterBlockType.Button),
+  label: z.string(),
+  url: z.string(),
+  align: Align,
+  color: z.string().optional(),
+});
+
+export const DividerBlockSchema = z.object({
+  key: z.string(),
+  type: z.literal(NewsletterBlockType.Divider),
+  thickness: z.number().int().min(1).max(10).optional(),
+  color: z.string().optional(),
+});
+
+export const NewsletterBlockSchema = z.discriminatedUnion("type", [
+  HeadingBlockSchema,
+  ParagraphBlockSchema,
+  ButtonBlockSchema,
+  DividerBlockSchema,
+]);
+
+export type HeadingBlock = z.infer<typeof HeadingBlockSchema>;
+export type ParagraphBlock = z.infer<typeof ParagraphBlockSchema>;
+export type ButtonBlock = z.infer<typeof ButtonBlockSchema>;
+export type DividerBlock = z.infer<typeof DividerBlockSchema>;
+export type NewsletterBlock = z.infer<typeof NewsletterBlockSchema>;
+
+/*
+|------------------------------------------------------------------------
+| Category
+|------------------------------------------------------------------------
+*/
+
+export const NewsletterCategorySchema = z.object({
+  type: z.literal("newsletter_category").optional(),
+  id: z.number(),
+  key: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  is_mandatory: z.boolean(),
+  is_active: z.boolean(),
+  sort_order: z.number().int(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+});
+
+export type NewsletterCategory = z.infer<typeof NewsletterCategorySchema>;
+
+/*
+|------------------------------------------------------------------------
+| Template
+|------------------------------------------------------------------------
+*/
+
+const UserBasicSchema = z
+  .object({
+    id: z.number(),
+    name: z.string(),
+    email: z.string().optional(),
+  })
+  .nullable();
+
+export const NewsletterTemplateSchemaSchema = z.object({
+  blocks: z.array(NewsletterBlockSchema),
+  variables_used: z.array(z.string()).optional(),
+});
+
+export type NewsletterTemplateDoc = z.infer<typeof NewsletterTemplateSchemaSchema>;
+
+export const NewsletterTemplateSchema = z.object({
+  type: z.literal("newsletter_template").optional(),
+  id: z.number(),
+  company_id: z.number().nullable(),
+  is_system: z.boolean().optional(),
+  newsletter_category_id: z.number(),
+  category: NewsletterCategorySchema.nullish(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().nullable().optional(),
+  subject: z.string(),
+  preheader: z.string().nullable().optional(),
+  schema: NewsletterTemplateSchemaSchema,
+  schema_version: z.number().int(),
+  is_active: z.boolean(),
+  created_by: z.number().nullable().optional(),
+  creator: UserBasicSchema.optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+});
+
+export type NewsletterTemplate = z.infer<typeof NewsletterTemplateSchema>;
+
+export const CreateNewsletterTemplateInputSchema = z.object({
+  newsletter_category_id: z.number(),
+  name: z.string().min(1),
+  slug: z.string().optional(),
+  description: z.string().nullable().optional(),
+  subject: z.string().min(1),
+  preheader: z.string().nullable().optional(),
+  schema: NewsletterTemplateSchemaSchema,
+  is_active: z.boolean().optional(),
+});
+
+export type CreateNewsletterTemplateInput = z.infer<typeof CreateNewsletterTemplateInputSchema>;
+export type UpdateNewsletterTemplateInput = Partial<CreateNewsletterTemplateInput>;
+
+/*
+|------------------------------------------------------------------------
+| Audience
+|------------------------------------------------------------------------
+*/
+
+export enum AudienceBucketType {
+  AllUsers = "all_users",
+  CompanyUsers = "company_users",
+  RoleMembers = "role_members",
+}
+
+export const AllUsersBucketSchema = z.object({ type: z.literal(AudienceBucketType.AllUsers) });
+export const CompanyUsersBucketSchema = z.object({
+  type: z.literal(AudienceBucketType.CompanyUsers),
+  company_ids: z.array(z.number()).min(1),
+});
+export const RoleMembersBucketSchema = z.object({
+  type: z.literal(AudienceBucketType.RoleMembers),
+  role_ids: z.array(z.number()).min(1),
+});
+
+export const AudienceBucketSchema = z.discriminatedUnion("type", [
+  AllUsersBucketSchema,
+  CompanyUsersBucketSchema,
+  RoleMembersBucketSchema,
+]);
+
+export const NewsletterAudienceSchema = z.object({
+  version: z.literal(1),
+  include: z.array(AudienceBucketSchema).min(1),
+  exclude: z
+    .object({
+      emails: z.array(z.string().email()).optional(),
+      user_ids: z.array(z.number()).optional(),
+    })
+    .optional(),
+});
+
+export type AudienceBucket = z.infer<typeof AudienceBucketSchema>;
+export type NewsletterAudience = z.infer<typeof NewsletterAudienceSchema>;
+
+/**
+ * Company-admin audience rule: the role selection is the sole determinant.
+ * No roles selected → the whole company (company_users). One or more roles
+ * → only those role-holders (role_members), and the company-wide bucket is
+ * dropped so the send-time union (ResolveCampaignAudienceAction) cannot
+ * widen the audience back to everyone.
+ */
+export function companyAudienceInclude(
+  companyId: number,
+  roleIds: number[],
+): AudienceBucket[] {
+  return roleIds.length > 0
+    ? [{ type: AudienceBucketType.RoleMembers, role_ids: roleIds }]
+    : [{ type: AudienceBucketType.CompanyUsers, company_ids: [companyId] }];
+}
+
+/*
+|------------------------------------------------------------------------
+| Campaign
+|------------------------------------------------------------------------
+*/
+
+export enum NewsletterCampaignStatus {
+  Draft = "draft",
+  Scheduled = "scheduled",
+  Sending = "sending",
+  Sent = "sent",
+  Failed = "failed",
+  Cancelled = "cancelled",
+}
+
+export const NewsletterCampaignSchema = z.object({
+  type: z.literal("newsletter_campaign").optional(),
+  id: z.number(),
+  company_id: z.number().nullable(),
+  is_system: z.boolean().optional(),
+  newsletter_template_id: z.number().nullable(),
+  template: NewsletterTemplateSchema.partial().nullish(),
+  newsletter_category_id: z.number(),
+  category: NewsletterCategorySchema.nullish(),
+  name: z.string(),
+  subject: z.string(),
+  preheader: z.string().nullable().optional(),
+  schema_snapshot: NewsletterTemplateSchemaSchema,
+  variables: z.record(z.string()).nullable().optional(),
+  audience_definition: NewsletterAudienceSchema,
+  status: z.nativeEnum(NewsletterCampaignStatus),
+  scheduled_at: z.string().nullable().optional(),
+  started_at: z.string().nullable().optional(),
+  finished_at: z.string().nullable().optional(),
+  cancelled_at: z.string().nullable().optional(),
+  counts: z.object({
+    queued: z.number().nullable(),
+    sent: z.number(),
+    failed: z.number(),
+    bounced: z.number(),
+    complained: z.number(),
+  }),
+  sent_by_user_id: z.number().nullable().optional(),
+  sent_by: UserBasicSchema.optional(),
+  can: z
+    .object({
+      update: z.boolean(),
+      schedule: z.boolean(),
+      send: z.boolean(),
+      cancel: z.boolean(),
+      test_send: z.boolean(),
+      delete: z.boolean(),
+    })
+    .partial()
+    .optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+});
+
+export type NewsletterCampaign = z.infer<typeof NewsletterCampaignSchema>;
+
+export const CreateNewsletterCampaignInputSchema = z.object({
+  newsletter_template_id: z.number().nullable().optional(),
+  newsletter_category_id: z.number().optional(),
+  name: z.string().min(1),
+  subject: z.string().optional(),
+  preheader: z.string().nullable().optional(),
+  schema_snapshot: NewsletterTemplateSchemaSchema.optional(),
+  variables: z.record(z.string()).optional(),
+  audience_definition: NewsletterAudienceSchema,
+});
+
+export type CreateNewsletterCampaignInput = z.infer<typeof CreateNewsletterCampaignInputSchema>;
+export type UpdateNewsletterCampaignInput = Partial<CreateNewsletterCampaignInput>;
+
+/*
+|------------------------------------------------------------------------
+| Recipient
+|------------------------------------------------------------------------
+*/
+
+export enum NewsletterRecipientStatus {
+  Queued = "queued",
+  Sent = "sent",
+  Failed = "failed",
+  Bounced = "bounced",
+  Complained = "complained",
+  Suppressed = "suppressed",
+  OptedOut = "opted_out",
+}
+
+export const NewsletterCampaignRecipientSchema = z.object({
+  type: z.literal("newsletter_campaign_recipient").optional(),
+  id: z.number(),
+  newsletter_campaign_id: z.number(),
+  user_id: z.number().nullable(),
+  user: UserBasicSchema.optional(),
+  email: z.string(),
+  status: z.nativeEnum(NewsletterRecipientStatus),
+  error: z.string().nullable().optional(),
+  message_id: z.string().nullable().optional(),
+  queued_at: z.string().nullable().optional(),
+  sent_at: z.string().nullable().optional(),
+  bounced_at: z.string().nullable().optional(),
+  complained_at: z.string().nullable().optional(),
+});
+
+export type NewsletterCampaignRecipient = z.infer<typeof NewsletterCampaignRecipientSchema>;
+
+/*
+|------------------------------------------------------------------------
+| Preference (per-user per-category)
+|------------------------------------------------------------------------
+*/
+
+export const NewsletterPreferenceRowSchema = z.object({
+  category_id: z.number(),
+  category_key: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  is_mandatory: z.boolean(),
+  opted_in: z.boolean(),
+});
+
+export type NewsletterPreferenceRow = z.infer<typeof NewsletterPreferenceRowSchema>;
+
+/*
+|------------------------------------------------------------------------
+| Variable allowlist (must mirror backend NewsletterBlocksValidator)
+|------------------------------------------------------------------------
+*/
+
+export const ALLOWED_NEWSLETTER_VARIABLES = [
+  "user.name",
+  "user.first_name",
+  "user.email",
+  "company.name",
+  "unsubscribe_url",
+] as const;
+
+export type AllowedNewsletterVariable = (typeof ALLOWED_NEWSLETTER_VARIABLES)[number];

package/src/schemas/todo.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+export const TodoActionSchema = z.object({
+  type: z.enum(["open_dialog", "navigate"]),
+  target: z.string(),
+  params: z.record(z.any()).optional(),
+});
+
+export const TodoKey = z.enum([
+  "fill_form",
+  "sign_form",
+  "review_form",
+  "log_booking",
+  "add_address",
+  "add_required_documents",
+  "fill_training_record",
+  "sign_training_record",
+]);
+
+export const TodoSchema = z.object({
+  key: TodoKey,
+  ref_type: z.string(),
+  ref_id: z.number(),
+  title: z.string(),
+  subtitle: z.string().nullable().optional(),
+  due_date: z.string().nullable().optional(),
+  is_overdue: z.boolean().default(false),
+  priority: z.enum(["low", "normal", "high"]).default("normal"),
+  company_id: z.number().nullable().optional(),
+  action: TodoActionSchema,
+  meta: z.record(z.any()).optional(),
+});
+
+export type Todo = z.infer<typeof TodoSchema>;
+export type TodoAction = z.infer<typeof TodoActionSchema>;
+
+/**
+ * Shape of one entry in `meta.accepted_alternatives` on
+ * `add_required_documents` todos — the other templates of the requirement's
+ * OR bucket that would satisfy it equally (backend:
+ * MissingDocumentTodoSource::selectOrAlternative()).
+ */
+export interface TodoAcceptedAlternative {
+  form_template_id: number;
+  form_template_name: string | null;
+}