@m5kdev/commons 0.1.0

package/src/modules/ai/ai.constants.ts

@@ -0,0 +1,305 @@
+// Models > $1/M tokens
+export const GPT_5_CHAT = "openai/gpt-5-chat";
+export const GPT_5_1 = "openai/gpt-5.1";
+export const GPT_5_2 = "openai/gpt-5.2";
+export const GEMINI_3_1_PRO = "google/gemini-3.1-pro-preview";
+export const GEMINI_2_5_PRO = "google/gemini-2.5-pro";
+export const GEMINI_3_PRO = "google/gemini-3-pro-preview";
+export const GEMINI_3_FLASH = "google/gemini-3-flash-preview";
+export const GROK_4 = "x-ai/grok-4";
+export const CLAUDE_SONNET_4 = "anthropic/claude-sonnet-4";
+export const CLAUDE_SONNET_4_5 = "anthropic/claude-sonnet-4.5";
+export const CLAUDE_OPUS_4_5 = "anthropic/claude-opus-4.5";
+export const CLAUDE_SONNET_4_6 = "anthropic/claude-sonnet-4.6";
+export const CLAUDE_OPUS_4_6 = "anthropic/claude-opus-4.6";
+export const MINIMAX_M2 = "minimax/minimax-m2";
+export const QWEN3_MAX = "qwen/qwen3-max";
+export const O3 = "openai/o3";
+
+// Models < $1/M tokens
+export const GPT_5_MINI = "openai/gpt-5-mini";
+export const GEMINI_2_5_FLASH = "google/gemini-2.5-flash";
+export const GROK_3_MINI = "x-ai/grok-3-mini";
+export const GROK_4_FAST = "x-ai/grok-4-fast";
+export const KIMI_K2_THINKING = "moonshotai/kimi-k2-thinking";
+export const KIMI_K2 = "moonshotai/kimi-k2-0905";
+export const KIMI_K2_5 = "moonshotai/kimi-k2.5";
+export const CLAUDE_SONNET_3_HAIKU = "anthropic/claude-3-haiku";
+export const GLM_4_5V = "z-ai/glm-4.5v";
+export const GLM_4_6 = "z-ai/glm-4.6";
+export const DEEPSEEK_V3_1 = "deepseek/deepseek-chat-v3.1";
+export const DEEPSEEK_R1 = "deepseek/deepseek-r1-0528";
+export const LLAMA_3_3_70B_INSTRUCT = "meta-llama/llama-3.3-70b-instruct";
+export const MISTRAL_3_1_MEDIUM = "mistralai/mistral-medium-3.1";
+
+// Models < $0.1/M tokens
+export const QWEN3_30B_A3B = "qwen/qwen3-30b-a3b";
+export const GPT_5_NANO = "openai/gpt-5-nano";
+export const GEMINI_2_5_FLASH_LITE = "google/gemini-2.5-flash-lite";
+
+// Embedding Models
+export const OPENAI_TEXT_EMBEDDING_3_SMALL = "openai/text-embedding-3-small";
+
+export const AI_EMBEDDING_MODELS = [OPENAI_TEXT_EMBEDDING_3_SMALL] as const;
+
+export type AiEmbeddingModel = (typeof AI_EMBEDDING_MODELS)[number];
+
+// Models by utility
+export const SCORER_BEST = GEMINI_3_FLASH;
+export const SCORER_FAST = KIMI_K2_5;
+export const RESONING_BEST = GEMINI_3_1_PRO;
+export const RESONING_FAST = KIMI_K2_5;
+export const STRUCTURED_OUTPUT_BEST = CLAUDE_SONNET_4_5;
+export const STRUCTURED_OUTPUT_FAST = GPT_5_MINI;
+export const TOOL_CALL_BEST = CLAUDE_SONNET_4_5;
+export const TOOL_CALL_FAST = GPT_5_MINI;
+
+export const AI_MODELS = [
+  LLAMA_3_3_70B_INSTRUCT,
+  QWEN3_30B_A3B,
+  GEMINI_2_5_PRO,
+  GEMINI_3_PRO,
+  GEMINI_3_FLASH,
+  DEEPSEEK_R1,
+  O3,
+  GPT_5_1,
+  GPT_5_2,
+  GPT_5_CHAT,
+  GROK_4,
+  CLAUDE_SONNET_4,
+  CLAUDE_SONNET_4_5,
+  CLAUDE_OPUS_4_5,
+  GPT_5_MINI,
+  GLM_4_5V,
+  MISTRAL_3_1_MEDIUM,
+  GEMINI_2_5_FLASH,
+  GROK_3_MINI,
+  CLAUDE_SONNET_3_HAIKU,
+  GPT_5_NANO,
+  GEMINI_2_5_FLASH_LITE,
+  GROK_4_FAST,
+  MINIMAX_M2,
+  KIMI_K2,
+  KIMI_K2_THINKING,
+  DEEPSEEK_V3_1,
+  GLM_4_6,
+  QWEN3_MAX,
+] as const;
+
+export const AI_MODELS_REGISTRY: AiModelRegistry = {
+  [O3]: {
+    name: "O3",
+    provider: "openai",
+    icon: "ti-brand-openai",
+    tier: "pro",
+    order: 1,
+  },
+  [MISTRAL_3_1_MEDIUM]: {
+    name: "Mistral 3.1 Medium",
+    provider: "mistralai",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [DEEPSEEK_R1]: {
+    name: "DeepSeek R1",
+    provider: "deepseek",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [QWEN3_30B_A3B]: {
+    name: "Qwen3 30B A3B",
+    provider: "qwen",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [LLAMA_3_3_70B_INSTRUCT]: {
+    name: "LLama 3.3 70B",
+    provider: "meta-llama",
+    icon: "ti-brand-meta",
+    tier: "pro",
+    order: 1,
+  },
+  [GLM_4_5V]: {
+    name: "GLM 4.5V",
+    provider: "z-ai",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [GLM_4_6]: {
+    name: "GLM 4.6",
+    provider: "z-ai",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [QWEN3_MAX]: {
+    name: "Qwen3 Max",
+    provider: "qwen",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [DEEPSEEK_V3_1]: {
+    name: "DeepSeek V3.1",
+    provider: "deepseek",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [KIMI_K2]: {
+    name: "Kimi K2",
+    provider: "moonshotai",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [KIMI_K2_THINKING]: {
+    name: "Kimi K2 Thinking",
+    provider: "moonshotai",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [CLAUDE_SONNET_4_5]: {
+    name: "Claude Sonnet 4.5",
+    provider: "anthropic",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [GPT_5_1]: {
+    name: "GPT-5.1",
+    provider: "openai",
+    icon: "ti-brand-openai",
+    tier: "pro",
+    order: 1,
+  },
+  [GPT_5_2]: {
+    name: "GPT-5.2",
+    provider: "openai",
+    icon: "ti-brand-openai",
+    tier: "pro",
+    order: 1,
+  },
+  [MINIMAX_M2]: {
+    name: "MiniMax M2",
+    provider: "minimax",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [GEMINI_2_5_PRO]: {
+    name: "Gemini 2.5 Pro",
+    provider: "google",
+    icon: "ti-brand-google",
+    tier: "pro",
+    order: 1,
+  },
+  [GEMINI_3_PRO]: {
+    name: "Gemini 3 Pro",
+    provider: "google",
+    icon: "ti-brand-google",
+    tier: "pro",
+    order: 1,
+  },
+  [GEMINI_3_FLASH]: {
+    name: "Gemini 3 Flash",
+    provider: "google",
+    icon: "ti-brand-google",
+    tier: "pro",
+    order: 1,
+  },
+  [GPT_5_CHAT]: {
+    name: "GPT-5",
+    provider: "openai",
+    icon: "ti-brand-openai",
+    tier: "pro",
+    order: 2,
+  },
+  [GROK_4]: {
+    name: "Grok 4",
+    provider: "x-ai",
+    icon: "ti-brand-x",
+    tier: "pro",
+    order: 3,
+  },
+  [GROK_4_FAST]: {
+    name: "Grok 4 Fast",
+    provider: "x-ai",
+    icon: "ti-brand-x",
+    tier: "pro",
+    order: 4,
+  },
+  [CLAUDE_SONNET_4]: {
+    name: "Claude Sonnet 4",
+    provider: "anthropic",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 4,
+  },
+  [CLAUDE_OPUS_4_5]: {
+    name: "Claude Opus 4.5",
+    provider: "anthropic",
+    icon: "ti-ai",
+    tier: "pro",
+    order: 1,
+  },
+  [GPT_5_MINI]: {
+    name: "GPT-5 Mini",
+    provider: "openai",
+    icon: "ti-brand-openai",
+    tier: "standard",
+    order: 5,
+  },
+  [GEMINI_2_5_FLASH]: {
+    name: "Gemini 2.5 Flash",
+    provider: "google",
+    icon: "ti-brand-google",
+    tier: "standard",
+    order: 6,
+  },
+  [GROK_3_MINI]: {
+    name: "Grok 3 Mini",
+    provider: "x-ai",
+    icon: "ti-brand-x",
+    tier: "standard",
+    order: 7,
+  },
+  [CLAUDE_SONNET_3_HAIKU]: {
+    name: "Claude Sonnet 3 Haiku",
+    provider: "anthropic",
+    icon: "ti-brand-anthropic",
+    tier: "standard",
+    order: 8,
+  },
+  [GPT_5_NANO]: {
+    name: "GPT-5 Nano",
+    provider: "openai",
+    icon: "ti-brand-openai",
+    tier: "fast",
+    order: 9,
+  },
+  [GEMINI_2_5_FLASH_LITE]: {
+    name: "Gemini 2.5 Flash Lite",
+    provider: "google",
+    icon: "ti-brand-google",
+    tier: "fast",
+    order: 10,
+  },
+};
+
+export type AiModel = (typeof AI_MODELS)[number];
+export type AiModelRegistry = Record<
+  AiModel,
+  {
+    name: string;
+    provider: string;
+    icon: string;
+    tier: string;
+    order: number;
+  }
+>;

package/src/modules/ai/ai.utils.ts

@@ -0,0 +1,14 @@
+export function arrayToPseudoXML<T extends Record<string, unknown>>(
+  array: readonly T[],
+  keys: readonly (keyof T)[],
+  name = "item"
+): string {
+  return array
+    .map(
+      (item) =>
+        `<${name}>${keys
+          .map((key) => `<${String(key)}>${String(item[key])}</${String(key)}>`)
+          .join("\n")}</${name}>`
+    )
+    .join("\n");
+}

package/src/modules/auth/auth.schema.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+export const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string(),
+  emailVerified: z.boolean(),
+  image: z.string().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  role: z.string().nullable(),
+  banned: z.boolean().nullable(),
+  banReason: z.string().nullable(),
+  banExpires: z.date().nullable(),
+  paymentCustomerId: z.string().nullable(),
+  paymentPlanTier: z.string().nullable(),
+  paymentPlanExpiresAt: z.date().nullable(),
+  preferences: z.string().nullable(),
+  onboarding: z.boolean().nullable(),
+});
+
+export type UserSchema = z.infer<typeof userSchema>;

package/src/modules/base/base.schema.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+export const uuidSchema = z.object({
+  id: z.uuid(),
+});
+
+export const uuidManySchema = z.object({
+  ids: z.array(z.uuid()),
+});
+
+export const scheduleOutputSchema = z.object({
+  jobId: z.string(),
+});
+
+export const scheduleManyOutputSchema = z.object({
+  jobIds: z.array(z.string()),
+});
+
+export const deleteOutputSchema = uuidSchema;
+export const deleteManyOutputSchema = uuidManySchema;
+
+export type UuidSchema = z.infer<typeof uuidSchema>;
+export type UuidManySchema = z.infer<typeof uuidManySchema>;
+export type ScheduleOutputSchema = z.infer<typeof scheduleOutputSchema>;
+export type ScheduleManyOutputSchema = z.infer<typeof scheduleManyOutputSchema>;
+export type DeleteOutputSchema = z.infer<typeof deleteOutputSchema>;
+export type DeleteManyInputSchema = z.infer<typeof deleteManyOutputSchema>;

package/src/modules/billing/billing.schema.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+export const billingSchema = z.object({
+  id: z.string(),
+  plan: z.string(),
+  referenceId: z.string(),
+  stripeCustomerId: z.string().nullish(),
+  stripeSubscriptionId: z.string().nullish(),
+  status: z.string(),
+  periodStart: z.date().nullish(),
+  periodEnd: z.date().nullish(),
+  cancelAtPeriodEnd: z.boolean().nullish(),
+  cancelAt: z.date().nullish(),
+  canceledAt: z.date().nullish(),
+  seats: z.number().nullish(),
+  trialStart: z.date().nullish(),
+  trialEnd: z.date().nullish(),
+  priceId: z.string().nullish(),
+  interval: z.string().nullish(),
+  unitAmount: z.number().nullish(),
+  discounts: z.array(z.string()).nullish(),
+});
+
+export type BillingSchema = z.infer<typeof billingSchema>;

package/src/modules/billing/billing.types.ts

@@ -0,0 +1,18 @@
+export type StripePlan = {
+  name: string;
+  priceId: string;
+  priceUnitAmount?: number;
+  annualDiscountPriceId?: string;
+  annualPriceUnitAmount?: number;
+  freeTrial?: {
+    days: number;
+  };
+  limits?: Record<string, number>;
+  group?: string;
+};
+
+export type StripePlansConfig = {
+  production: StripePlan[];
+  sandbox: StripePlan[];
+  trialPlanName?: string;
+};

package/src/modules/billing/billing.utils.ts

@@ -0,0 +1,13 @@
+import type { StripePlan, StripePlansConfig } from "./billing.types";
+
+export const getEnvironmentPlans = (
+  plansConfig: StripePlansConfig,
+  environment = "sandbox"
+): { plans: StripePlan[]; trial: StripePlan | undefined } => {
+  const isProduction = environment === "production";
+  const plans = isProduction ? plansConfig.production : plansConfig.sandbox;
+  const trial = plansConfig.trialPlanName
+    ? plans.find((plan) => plan.name === plansConfig.trialPlanName)
+    : undefined;
+  return { plans, trial };
+};

package/src/modules/file/file.constants.ts

@@ -0,0 +1,14 @@
+export const fileTypes: Record<string, { mimetypes: string[]; extensions: string[] }> = {
+  image: {
+    mimetypes: ["image/jpeg", "image/png", "image/jpg", "image/webp"],
+    extensions: ["jpg", "jpeg", "png", "webp"],
+  },
+  video: {
+    mimetypes: ["video/mp4", "video/mov", "video/avi", "video/mkv", "video/webm"],
+    extensions: ["mp4", "mov", "avi", "mkv"],
+  },
+  audio: {
+    mimetypes: ["audio/mp3", "audio/wav", "audio/m4a", "audio/webm"],
+    extensions: ["mp3", "wav", "m4a", "webm"],
+  },
+} as const;

package/src/modules/recurrence/recurrence.schema.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+
+// Reusable schemas for JSON-by-* fields (number or number[])
+const numberOrNumberArraySchema = z.union([z.number(), z.array(z.number())]).nullish();
+
+export const recurrenceMetadataSchema = z.record(z.string(), z.unknown()).nullish();
+
+export const recurrenceSchema = z.object({
+  id: z.string(),
+  userId: z.string().nullish(),
+  organizationId: z.string().nullish(),
+  teamId: z.string().nullish(),
+  name: z.string().nullish(),
+  kind: z.string().nullish(),
+  enabled: z.boolean(),
+  metadata: recurrenceMetadataSchema,
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const recurrenceRulesSchema = z.object({
+  id: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  recurrenceId: z.string().nullish(),
+  freq: z.number(),
+  dtstart: z.date().nullish(),
+  interval: z.number(),
+  wkst: z.number().nullish(),
+  count: z.number().nullish(),
+  until: z.date().nullish(),
+  tzid: z.string().nullish(),
+  bysetpos: numberOrNumberArraySchema,
+  bymonth: numberOrNumberArraySchema,
+  bymonthday: numberOrNumberArraySchema,
+  byyearday: numberOrNumberArraySchema,
+  byweekno: numberOrNumberArraySchema,
+  byweekday: numberOrNumberArraySchema,
+  byhour: numberOrNumberArraySchema,
+  byminute: numberOrNumberArraySchema,
+  bysecond: numberOrNumberArraySchema,
+});
+export const updateRecurrenceRulesSchema = recurrenceRulesSchema.omit({
+  createdAt: true,
+  updatedAt: true,
+  recurrenceId: true,
+});
+
+export const createRecurrenceSchema = z.object({
+  name: z.string(),
+  kind: z.string(),
+  enabled: z.boolean(),
+  metadata: recurrenceMetadataSchema,
+  recurrenceRules: z.array(updateRecurrenceRulesSchema.omit({ id: true })),
+});
+
+export const updateRecurrenceSchema = z.object({
+  name: z.string().optional(),
+  kind: z.string().optional(),
+  enabled: z.boolean().optional(),
+  metadata: recurrenceMetadataSchema,
+});
+
+export const deleteRecurrenceSchema = z.object({
+  id: z.string(),
+});
+
+export const deleteRecurrenceRulesSchema = z.object({
+  id: z.string(),
+});
+
+export type RecurrenceSchema = z.infer<typeof recurrenceSchema>;
+export type RecurrenceRulesSchema = z.infer<typeof recurrenceRulesSchema>;
+export type CreateRecurrenceSchema = z.infer<typeof createRecurrenceSchema>;
+export type UpdateRecurrenceSchema = z.infer<typeof updateRecurrenceSchema>;
+export type UpdateRecurrenceRulesSchema = z.infer<typeof updateRecurrenceRulesSchema>;
+export type DeleteRecurrenceSchema = z.infer<typeof deleteRecurrenceSchema>;
+export type DeleteRecurrenceRulesSchema = z.infer<typeof deleteRecurrenceRulesSchema>;

package/src/modules/schemas/query.schema.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+export const filterSchema = z.object({
+  columnId: z.string(),
+  type: z.enum(["string", "number", "date", "boolean", "enum"]),
+  method: z.enum([
+    "contains",
+    "equals",
+    "starts_with",
+    "ends_with",
+    "greater_than",
+    "less_than",
+    "on",
+    "between",
+    "before",
+    "after",
+    "oneOf",
+    "intersect",
+    "isEmpty",
+    "isNotEmpty",
+    "is_null",
+    "is_not_null",
+  ]),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]),
+  valueTo: z.string().optional(),
+  endColumnId: z.string().optional(),
+});
+
+export const filtersSchema = z.array(filterSchema);
+
+export const querySchema = z.object({
+  // TODO: Remove default values
+  page: z.number().optional(),
+  limit: z.number().optional(),
+  sort: z.string().optional(),
+  order: z.enum(["asc", "desc"]).optional(),
+  filters: filtersSchema.optional(),
+});
+
+export type QueryListOutput<T> = { rows: T[]; total: number };
+
+export type QueryInput = z.infer<typeof querySchema>;
+export type QueryFilter = z.infer<typeof filterSchema>;
+export type QueryFilters = z.infer<typeof filtersSchema>;

package/src/modules/table/filter.types.ts

@@ -0,0 +1,39 @@
+import type { QueryFilter } from "../schemas/query.schema";
+
+export type ColumnDataType = NonNullable<QueryFilter["type"]>;
+
+export type ComponentForFilterMethod =
+  | "text"
+  | "number"
+  | "date"
+  | "range"
+  | "radio"
+  | "select"
+  | "multiSelect";
+
+export type FilterMethodName =
+  | "contains"
+  | "equals"
+  | "starts_with"
+  | "ends_with"
+  | "greater_than"
+  | "less_than"
+  | "on"
+  | "between"
+  | "before"
+  | "after"
+  | "intersect"
+  | "oneOf"
+  | "isEmpty"
+  | "isNotEmpty";
+
+export type FilterMethod = {
+  value: FilterMethodName;
+  label: string;
+  component?: ComponentForFilterMethod | null;
+};
+
+export type FilterMethods = {
+  [key in ColumnDataType]: FilterMethod[];
+};
+

package/src/modules/tag/tag.schema.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { querySchema } from "../schemas/query.schema";
+
+export const tagSchema = z.object({
+  id: z.string(),
+  organizationId: z.string().nullish(),
+  teamId: z.string().nullish(),
+  createdAt: z.date(),
+  updatedAt: z.date().nullish(),
+  deletedAt: z.date().nullish(),
+  userId: z.string(),
+  name: z.string(),
+  color: z.string().nullish(),
+  type: z.string().nullish(),
+  isEnabled: z.boolean(),
+  parentId: z.string().nullish(),
+  assignableTo: z.string().array().nullish().default([]),
+});
+
+export const taggingSchema = z.object({
+  id: z.string(),
+  createdAt: z.date(),
+  tagId: z.string(),
+  resourceType: z.string(),
+  resourceId: z.string(),
+});
+
+export const tagListInputSchema = querySchema;
+
+export const tagListOutputSchema = z.object({
+  rows: z.array(tagSchema),
+  total: z.number(),
+});
+
+export const tagListSchema = z.object({
+  assignableTo: z.string().optional(),
+});
+
+export const tagCreateSchema = z.object({
+  organizationId: z.string().optional(),
+  teamId: z.string().optional(),
+  name: z.string(),
+  color: z.string(),
+  assignableTo: z.string().array().optional().default([]),
+  resourceType: z.string().optional(),
+  resourceId: z.string().optional(),
+});
+
+export const tagUpdateSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  color: z.string().optional(),
+});
+
+export const tagLinkSchema = z.object({
+  tagId: z.string(),
+  resourceType: z.string(),
+  resourceId: z.string(),
+});
+
+export type TagSchema = z.infer<typeof tagSchema>;
+export type TaggingSchema = z.infer<typeof taggingSchema>;
+export type TagListSchema = z.infer<typeof tagListSchema>;
+export type TagCreateSchema = z.infer<typeof tagCreateSchema>;
+export type TagUpdateSchema = z.infer<typeof tagUpdateSchema>;
+export type TagLinkSchema = z.infer<typeof tagLinkSchema>;
+export type TagListOutputSchema = z.infer<typeof tagListOutputSchema>;
+export type TagListInputSchema = z.infer<typeof tagListInputSchema>;

package/src/modules/workflow/workflow.constants.ts

@@ -0,0 +1,2 @@
+export const WORFLOW_STATUSES = ["queued", "running", "completed", "failed"] as const;
+export type WorkflowStatus = (typeof WORFLOW_STATUSES)[number];