@hogsend/db 0.0.1

package/src/schema/email-preferences.ts

@@ -0,0 +1,35 @@
+import {
+  boolean,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+
+export const emailPreferences = pgTable(
+  "email_preferences",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    userId: text("user_id").notNull(),
+    email: text("email").notNull(),
+    unsubscribedAll: boolean("unsubscribed_all").notNull().default(false),
+    suppressed: boolean("suppressed").notNull().default(false),
+    bounceCount: integer("bounce_count").notNull().default(0),
+    categories: jsonb("categories")
+      .$type<Record<string, boolean>>()
+      .default({}),
+    suppressedAt: timestamp("suppressed_at", { withTimezone: true }),
+    lastBounceAt: timestamp("last_bounce_at", { withTimezone: true }),
+    ...timestamps,
+  },
+  (table) => [
+    uniqueIndex("email_preferences_user_email_idx").on(
+      table.userId,
+      table.email,
+    ),
+  ],
+);

package/src/schema/email-sends.ts

@@ -0,0 +1,34 @@
+import { index, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+import { emailSendStatusEnum } from "./enums.js";
+import { journeyStates } from "./journey-states.js";
+
+export const emailSends = pgTable(
+  "email_sends",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id"),
+    journeyStateId: uuid("journey_state_id").references(() => journeyStates.id),
+    templateKey: text("template_key"),
+    resendId: text("resend_id"),
+    fromEmail: text("from_email").notNull(),
+    toEmail: text("to_email").notNull(),
+    subject: text("subject").notNull(),
+    category: text("category"),
+    status: emailSendStatusEnum("status").notNull().default("queued"),
+    sentAt: timestamp("sent_at", { withTimezone: true }),
+    deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+    openedAt: timestamp("opened_at", { withTimezone: true }),
+    clickedAt: timestamp("clicked_at", { withTimezone: true }),
+    bouncedAt: timestamp("bounced_at", { withTimezone: true }),
+    complainedAt: timestamp("complained_at", { withTimezone: true }),
+    ...timestamps,
+  },
+  (table) => [
+    index("email_sends_to_email_idx").on(table.toEmail),
+    index("email_sends_template_key_idx").on(table.templateKey),
+    index("email_sends_status_idx").on(table.status),
+    index("email_sends_created_at_idx").on(table.createdAt),
+    index("email_sends_journey_state_id_idx").on(table.journeyStateId),
+  ],
+);

package/src/schema/enums.ts

@@ -0,0 +1,47 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+
+export const journeyStatusEnum = pgEnum("journey_status", [
+  "active",
+  "waiting",
+  "completed",
+  "failed",
+  "exited",
+]);
+
+export const emailSendStatusEnum = pgEnum("email_send_status", [
+  "queued",
+  "rendered",
+  "sent",
+  "delivered",
+  "opened",
+  "clicked",
+  "bounced",
+  "complained",
+  "failed",
+]);
+
+export const importJobStatusEnum = pgEnum("import_job_status", [
+  "pending",
+  "processing",
+  "completed",
+  "failed",
+]);
+
+export const alertRuleTypeEnum = pgEnum("alert_rule_type", [
+  "bounce_rate_exceeded",
+  "journey_failure_spike",
+  "delivery_issue",
+  "high_complaint_rate",
+]);
+
+export const alertChannelEnum = pgEnum("alert_channel", [
+  "webhook",
+  "slack",
+  "email",
+]);
+
+export const dlqStatusEnum = pgEnum("dlq_status", [
+  "pending",
+  "retried",
+  "discarded",
+]);

package/src/schema/import-jobs.ts

@@ -0,0 +1,26 @@
+import {
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+import { importJobStatusEnum } from "./enums.js";
+
+export const importJobs = pgTable(
+  "import_jobs",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    fileName: text("file_name"),
+    format: text("format").notNull(),
+    status: importJobStatusEnum("status").notNull().default("pending"),
+    totalRows: integer("total_rows"),
+    processedRows: integer("processed_rows").notNull().default(0),
+    failedRows: integer("failed_rows").notNull().default(0),
+    errors: jsonb("errors").$type<Array<{ row: number; error: string }>>(),
+    ...timestamps,
+  },
+  (table) => [index("import_jobs_status_idx").on(table.status)],
+);

package/src/schema/index.ts

@@ -0,0 +1,18 @@
+export * from "./alert-history.js";
+export * from "./alert-rules.js";
+export * from "./api-keys.js";
+export * from "./audit-logs.js";
+export * from "./auth.js";
+export * from "./contacts.js";
+export * from "./dead-letter-queue.js";
+export * from "./email-preferences.js";
+export * from "./email-sends.js";
+export * from "./enums.js";
+export * from "./import-jobs.js";
+export * from "./journey-configs.js";
+export * from "./journey-logs.js";
+export * from "./journey-states.js";
+export * from "./link-clicks.js";
+export * from "./relations.js";
+export * from "./tracked-links.js";
+export * from "./user-events.js";

package/src/schema/journey-configs.ts

@@ -0,0 +1,15 @@
+import { boolean, pgTable, text, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+
+export const journeyConfigs = pgTable(
+  "journey_configs",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    journeyId: text("journey_id").notNull(),
+    enabled: boolean("enabled").notNull().default(true),
+    ...timestamps,
+  },
+  (table) => [
+    uniqueIndex("journey_configs_journey_id_idx").on(table.journeyId),
+  ],
+);

package/src/schema/journey-logs.ts

@@ -0,0 +1,21 @@
+import { index, jsonb, pgTable, text, uuid } from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+import { journeyStates } from "./journey-states.js";
+
+export const journeyLogs = pgTable(
+  "journey_logs",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    journeyStateId: uuid("journey_state_id")
+      .notNull()
+      .references(() => journeyStates.id, { onDelete: "cascade" }),
+    fromNodeId: text("from_node_id"),
+    toNodeId: text("to_node_id"),
+    action: text("action").notNull(),
+    detail: jsonb("detail").$type<Record<string, unknown>>(),
+    ...timestamps,
+  },
+  (table) => [
+    index("journey_logs_journey_state_id_idx").on(table.journeyStateId),
+  ],
+);

package/src/schema/journey-states.ts

@@ -0,0 +1,54 @@
+import {
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+import { journeyStatusEnum } from "./enums.js";
+
+export const journeyStates = pgTable(
+  "journey_states",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id"),
+    userId: text("user_id").notNull(),
+    userEmail: text("user_email").notNull(),
+    journeyId: text("journey_id").notNull(),
+    currentNodeId: text("current_node_id").notNull(),
+    status: journeyStatusEnum("status").notNull().default("active"),
+    hatchetRunId: text("hatchet_run_id"),
+    context: jsonb("context").$type<Record<string, unknown>>().default({}),
+    errorMessage: text("error_message"),
+    entryCount: integer("entry_count").notNull().default(1),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    exitedAt: timestamp("exited_at", { withTimezone: true }),
+    deletedAt: timestamp("deleted_at", { withTimezone: true }),
+    ...timestamps,
+  },
+  (table) => [
+    // NOTE: organizationId is intentionally NOT in this unique index yet. It is
+    // nullable (single-tenant today), and Postgres treats NULLs as DISTINCT in a
+    // unique index by default — so adding it now would silently stop enforcing
+    // one-active-journey-per-user for all existing rows. drizzle 0.45.2's
+    // uniqueIndex() can't express NULLS NOT DISTINCT. When multi-tenancy lands and
+    // organizationId is non-null, add it to this key (a cheap rebuild on this
+    // modest table). The nullable column is added now (the real cheap insurance).
+    uniqueIndex("uq_user_journey_active").on(
+      table.userId,
+      table.journeyId,
+      table.status,
+    ),
+    index("journey_states_status_idx").on(table.status),
+    index("journey_states_hatchet_run_idx").on(table.hatchetRunId),
+    index("journey_states_user_id_idx").on(table.userId),
+    index("journey_states_journey_id_status_idx").on(
+      table.journeyId,
+      table.status,
+    ),
+  ],
+);

package/src/schema/link-clicks.ts

@@ -0,0 +1,21 @@
+import { index, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { trackedLinks } from "./tracked-links.js";
+
+export const linkClicks = pgTable(
+  "link_clicks",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    trackedLinkId: uuid("tracked_link_id")
+      .notNull()
+      .references(() => trackedLinks.id, { onDelete: "cascade" }),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    clickedAt: timestamp("clicked_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    index("link_clicks_tracked_link_id_idx").on(table.trackedLinkId),
+    index("link_clicks_clicked_at_idx").on(table.clickedAt),
+  ],
+);

package/src/schema/relations.ts

@@ -0,0 +1,160 @@
+import { relations } from "drizzle-orm";
+import { alertHistory } from "./alert-history.js";
+import { alertRules } from "./alert-rules.js";
+import { apiKeys } from "./api-keys.js";
+import { auditLogs } from "./audit-logs.js";
+import {
+  account,
+  invitation,
+  member,
+  organization,
+  session,
+  user,
+} from "./auth.js";
+import { contacts } from "./contacts.js";
+import { deadLetterQueue } from "./dead-letter-queue.js";
+import { emailPreferences } from "./email-preferences.js";
+import { emailSends } from "./email-sends.js";
+import { importJobs } from "./import-jobs.js";
+import { journeyConfigs } from "./journey-configs.js";
+import { journeyLogs } from "./journey-logs.js";
+import { journeyStates } from "./journey-states.js";
+import { linkClicks } from "./link-clicks.js";
+import { trackedLinks } from "./tracked-links.js";
+import { userEvents } from "./user-events.js";
+
+export const alertRulesRelations = relations(alertRules, ({ many }) => ({
+  history: many(alertHistory),
+}));
+
+export const alertHistoryRelations = relations(alertHistory, ({ one }) => ({
+  rule: one(alertRules, {
+    fields: [alertHistory.alertRuleId],
+    references: [alertRules.id],
+  }),
+}));
+
+export const apiKeysRelations = relations(apiKeys, () => ({}));
+
+export const auditLogsRelations = relations(auditLogs, () => ({}));
+
+export const deadLetterQueueRelations = relations(deadLetterQueue, () => ({}));
+
+export const importJobsRelations = relations(importJobs, () => ({}));
+
+export const journeyConfigsRelations = relations(journeyConfigs, () => ({}));
+
+export const contactsRelations = relations(contacts, ({ many }) => ({
+  emailPreferences: many(emailPreferences),
+  userEvents: many(userEvents),
+  journeyStates: many(journeyStates),
+}));
+
+export const emailPreferencesRelations = relations(
+  emailPreferences,
+  ({ one }) => ({
+    contact: one(contacts, {
+      fields: [emailPreferences.userId],
+      references: [contacts.externalId],
+    }),
+  }),
+);
+
+export const userEventsRelations = relations(userEvents, ({ one }) => ({
+  contact: one(contacts, {
+    fields: [userEvents.userId],
+    references: [contacts.externalId],
+  }),
+}));
+
+export const journeyStatesRelations = relations(
+  journeyStates,
+  ({ one, many }) => ({
+    contact: one(contacts, {
+      fields: [journeyStates.userId],
+      references: [contacts.externalId],
+    }),
+    logs: many(journeyLogs),
+    emailSends: many(emailSends),
+  }),
+);
+
+export const journeyLogsRelations = relations(journeyLogs, ({ one }) => ({
+  journeyState: one(journeyStates, {
+    fields: [journeyLogs.journeyStateId],
+    references: [journeyStates.id],
+  }),
+}));
+
+export const emailSendsRelations = relations(emailSends, ({ one, many }) => ({
+  journeyState: one(journeyStates, {
+    fields: [emailSends.journeyStateId],
+    references: [journeyStates.id],
+  }),
+  trackedLinks: many(trackedLinks),
+}));
+
+export const trackedLinksRelations = relations(
+  trackedLinks,
+  ({ one, many }) => ({
+    emailSend: one(emailSends, {
+      fields: [trackedLinks.emailSendId],
+      references: [emailSends.id],
+    }),
+    clicks: many(linkClicks),
+  }),
+);
+
+export const linkClicksRelations = relations(linkClicks, ({ one }) => ({
+  trackedLink: one(trackedLinks, {
+    fields: [linkClicks.trackedLinkId],
+    references: [trackedLinks.id],
+  }),
+}));
+
+export const userRelations = relations(user, ({ many }) => ({
+  sessions: many(session),
+  accounts: many(account),
+  memberships: many(member),
+}));
+
+export const sessionRelations = relations(session, ({ one }) => ({
+  user: one(user, {
+    fields: [session.userId],
+    references: [user.id],
+  }),
+}));
+
+export const accountRelations = relations(account, ({ one }) => ({
+  user: one(user, {
+    fields: [account.userId],
+    references: [user.id],
+  }),
+}));
+
+export const organizationRelations = relations(organization, ({ many }) => ({
+  members: many(member),
+  invitations: many(invitation),
+}));
+
+export const memberRelations = relations(member, ({ one }) => ({
+  organization: one(organization, {
+    fields: [member.organizationId],
+    references: [organization.id],
+  }),
+  user: one(user, {
+    fields: [member.userId],
+    references: [user.id],
+  }),
+}));
+
+export const invitationRelations = relations(invitation, ({ one }) => ({
+  organization: one(organization, {
+    fields: [invitation.organizationId],
+    references: [organization.id],
+  }),
+  inviter: one(user, {
+    fields: [invitation.inviterId],
+    references: [user.id],
+  }),
+}));

package/src/schema/tracked-links.ts

@@ -0,0 +1,17 @@
+import { index, integer, pgTable, text, uuid } from "drizzle-orm/pg-core";
+import { timestamps } from "./_shared.js";
+import { emailSends } from "./email-sends.js";
+
+export const trackedLinks = pgTable(
+  "tracked_links",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    emailSendId: uuid("email_send_id")
+      .notNull()
+      .references(() => emailSends.id, { onDelete: "cascade" }),
+    originalUrl: text("original_url").notNull(),
+    clickCount: integer("click_count").notNull().default(0),
+    ...timestamps,
+  },
+  (table) => [index("tracked_links_email_send_id_idx").on(table.emailSendId)],
+);

package/src/schema/user-events.ts

@@ -0,0 +1,35 @@
+import {
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+
+export const userEvents = pgTable(
+  "user_events",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id"),
+    userId: text("user_id").notNull(),
+    event: text("event").notNull(),
+    properties: jsonb("properties").$type<Record<string, unknown>>(),
+    idempotencyKey: text("idempotency_key"),
+    occurredAt: timestamp("occurred_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    index("user_events_user_id_idx").on(table.userId),
+    index("user_events_event_idx").on(table.event),
+    index("user_events_occurred_at_idx").on(table.occurredAt),
+    index("user_events_user_event_occurred_idx").on(
+      table.userId,
+      table.event,
+      table.occurredAt,
+    ),
+    uniqueIndex("user_events_idempotency_key_idx").on(table.idempotencyKey),
+  ],
+);

package/src/seed.ts

@@ -0,0 +1,91 @@
+import { sql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema/index.js";
+
+const databaseUrl = process.env.DATABASE_URL;
+if (!databaseUrl) {
+  console.error("DATABASE_URL environment variable is required");
+  process.exit(1);
+}
+
+const client = postgres(databaseUrl, { max: 1 });
+const db = drizzle(client, { schema });
+
+async function seed() {
+  console.log("Seeding database...");
+
+  const demoUserId = "seed-user-001";
+  const demoOrgId = "seed-org-001";
+
+  await db
+    .insert(schema.user)
+    .values({
+      id: demoUserId,
+      name: "Demo User",
+      email: "demo@hogsend.dev",
+      emailVerified: true,
+    })
+    .onConflictDoNothing();
+
+  await db
+    .insert(schema.organization)
+    .values({
+      id: demoOrgId,
+      name: "Hogsend Demo",
+      slug: "hogsend-demo",
+    })
+    .onConflictDoNothing();
+
+  await db
+    .insert(schema.member)
+    .values({
+      id: "seed-member-001",
+      organizationId: demoOrgId,
+      userId: demoUserId,
+      role: "owner",
+    })
+    .onConflictDoNothing();
+
+  await db
+    .insert(schema.contacts)
+    .values({
+      externalId: demoUserId,
+      email: "demo@hogsend.dev",
+      properties: { plan: "free", name: "Demo User" },
+    })
+    .onConflictDoNothing();
+
+  await db
+    .insert(schema.emailPreferences)
+    .values({
+      userId: demoUserId,
+      email: "demo@hogsend.dev",
+      unsubscribedAll: false,
+      categories: {},
+    })
+    .onConflictDoNothing();
+
+  await db
+    .delete(schema.userEvents)
+    .where(sql`${schema.userEvents.properties}->>'source' = 'seed'`);
+
+  await db.insert(schema.userEvents).values([
+    {
+      userId: demoUserId,
+      event: "user.created",
+      properties: { plan: "free", source: "seed" },
+    },
+    {
+      userId: demoUserId,
+      event: "feature.used",
+      properties: { feature: "dashboard", source: "seed" },
+    },
+  ]);
+
+  console.log("Seeding complete.");
+}
+
+await seed();
+await client.end();
+process.exit(0);