first

packages/database/drizzle/client.ts

@@ -0,0 +1,15 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+import * as schema from "./schema/postgres";
+
+// Check the drizzle documentation for more information on how to connect to your preferred database provider
+// https://orm.drizzle.team/docs/get-started-postgresql
+
+const databaseUrl = process.env.DATABASE_URL as string;
+
+if (!databaseUrl) {
+	throw new Error("DATABASE_URL is not set");
+}
+
+export const db = drizzle(databaseUrl, {
+	schema,
+});

packages/database/drizzle/drizzle.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+	dialect: "postgresql",
+	schema: "./drizzle/schema/postgres.ts",
+	dbCredentials: {
+		url: process.env.DATABASE_URL as string,
+	},
+});

packages/database/drizzle/index.ts

@@ -0,0 +1,4 @@
+export * from "./client";
+export * from "./zod";
+export * from "./queries";
+export * from "./schema";

packages/database/drizzle/queries/ai-chats.ts

@@ -0,0 +1,88 @@
+import { eq } from "drizzle-orm";
+import { db } from "../client";
+import { aiChat } from "../schema/postgres";
+
+export async function getAiChatsByUserId({
+	limit,
+	offset,
+	userId,
+}: {
+	limit: number;
+	offset: number;
+	userId: string;
+}) {
+	return await db.query.aiChat.findMany({
+		where: (aiChat, { eq }) => eq(aiChat.userId, userId),
+		limit,
+		offset,
+	});
+}
+
+export async function getAiChatsByOrganizationId({
+	limit,
+	offset,
+	organizationId,
+}: {
+	limit: number;
+	offset: number;
+	organizationId: string;
+}) {
+	return await db.query.aiChat.findMany({
+		where: (aiChat, { eq }) => eq(aiChat.organizationId, organizationId),
+		limit,
+		offset,
+	});
+}
+
+export async function getAiChatById(id: string) {
+	return db.query.aiChat.findFirst({
+		where: (aiChat, { eq }) => eq(aiChat.id, id),
+	});
+}
+
+export async function createAiChat({
+	organizationId,
+	userId,
+	title,
+}: {
+	organizationId?: string;
+	userId: string;
+	title?: string;
+}) {
+	const [{ id }] = await db
+		.insert(aiChat)
+		.values({
+			organizationId,
+			userId,
+			title,
+		})
+		.returning({ id: aiChat.id });
+
+	const createdChat = await getAiChatById(id);
+
+	if (!createdChat) {
+		throw new Error("Failed to create chat");
+	}
+
+	return createdChat;
+}
+
+export async function updateAiChat({
+	id,
+	title,
+	messages,
+}: {
+	id: string;
+	title?: string;
+	messages?: typeof aiChat.$inferInsert.messages;
+}) {
+	return await db
+		.update(aiChat)
+		.set({ title, messages })
+		.where(eq(aiChat.id, id))
+		.returning();
+}
+
+export async function deleteAiChat(id: string) {
+	return await db.delete(aiChat).where(eq(aiChat.id, id));
+}

packages/database/drizzle/queries/index.ts

@@ -0,0 +1,4 @@
+export * from "./organizations";
+export * from "./users";
+export * from "./ai-chats";
+export * from "./purchases";

packages/database/drizzle/queries/organizations.ts

@@ -0,0 +1,105 @@
+import { and, eq } from "drizzle-orm";
+import type { z } from "zod";
+import { db } from "../client";
+import { member, organization } from "../schema/postgres";
+import type { OrganizationUpdateSchema } from "../zod";
+
+export async function getOrganizations({
+	limit,
+	offset,
+	query,
+}: {
+	limit: number;
+	offset: number;
+	query?: string;
+}) {
+	return db.query.organization.findMany({
+		where: query
+			? (org, { like }) => like(org.name, `%${query}%`)
+			: undefined,
+		limit,
+		offset,
+		extras: {
+			membersCount: db
+				.$count(member, eq(member.organizationId, organization.id))
+				.as("membersCount"),
+		},
+	});
+}
+
+export async function countAllOrganizations() {
+	return db.$count(organization);
+}
+
+export async function getOrganizationById(id: string) {
+	return db.query.organization.findFirst({
+		where: (org, { eq }) => eq(org.id, id),
+		with: {
+			members: true,
+			invitations: true,
+		},
+	});
+}
+
+export async function getInvitationById(id: string) {
+	return db.query.invitation.findFirst({
+		where: (invitation, { eq }) => eq(invitation.id, id),
+		with: {
+			organization: true,
+		},
+	});
+}
+
+export async function getOrganizationBySlug(slug: string) {
+	return db.query.organization.findFirst({
+		where: (org, { eq }) => eq(org.slug, slug),
+	});
+}
+
+export async function getOrganizationMembership(
+	organizationId: string,
+	userId: string,
+) {
+	return db.query.member.findFirst({
+		where: (member, { eq }) =>
+			and(
+				eq(member.organizationId, organizationId),
+				eq(member.userId, userId),
+			),
+		with: {
+			organization: true,
+		},
+	});
+}
+
+export async function getOrganizationWithPurchasesAndMembersCount(
+	organizationId: string,
+) {
+	return db.query.organization.findFirst({
+		where: (org, { eq }) => eq(org.id, organizationId),
+		with: {
+			purchases: true,
+		},
+		extras: {
+			membersCount: db
+				.$count(member, eq(member.organizationId, organization.id))
+				.as("membersCount"),
+		},
+	});
+}
+
+export async function getPendingInvitationByEmail(email: string) {
+	return db.query.invitation.findFirst({
+		where: (invitation, { eq }) =>
+			and(eq(invitation.email, email), eq(invitation.status, "pending")),
+	});
+}
+
+export async function updateOrganization(
+	updatedOrganization: z.infer<typeof OrganizationUpdateSchema>,
+) {
+	return db
+		.update(organization)
+		.set(updatedOrganization)
+		.where(eq(organization.id, updatedOrganization.id));
+}

packages/database/drizzle/queries/purchases.ts

@@ -0,0 +1,59 @@
+import { eq } from "drizzle-orm";
+import type { z } from "zod";
+import { db } from "../client";
+import { purchase } from "../schema/postgres";
+import type { PurchaseInsertSchema, PurchaseUpdateSchema } from "../zod";
+
+export async function getPurchasesByOrganizationId(organizationId: string) {
+	return db.query.purchase.findMany({
+		where: (purchase, { eq }) =>
+			eq(purchase.organizationId, organizationId),
+	});
+}
+
+export async function getPurchasesByUserId(userId: string) {
+	return db.query.purchase.findMany({
+		where: (purchase, { eq }) => eq(purchase.userId, userId),
+	});
+}
+
+export async function getPurchaseById(id: string) {
+	return db.query.purchase.findFirst({
+		where: (purchase, { eq }) => eq(purchase.id, id),
+	});
+}
+
+export async function getPurchaseBySubscriptionId(subscriptionId: string) {
+	return db.query.purchase.findFirst({
+		where: (purchase, { eq }) =>
+			eq(purchase.subscriptionId, subscriptionId),
+	});
+}
+
+export async function createPurchase(
+	insertedPurchase: z.infer<typeof PurchaseInsertSchema>,
+) {
+	const [{ id }] = await db
+		.insert(purchase)
+		.values(insertedPurchase)
+		.returning({ id: purchase.id });
+
+	return getPurchaseById(id);
+}
+
+export async function updatePurchase(
+	updatedPurchase: z.infer<typeof PurchaseUpdateSchema>,
+) {
+	const [{ id }] = await db
+		.update(purchase)
+		.set(updatedPurchase)
+		.returning({ id: purchase.id });
+
+	return getPurchaseById(id);
+}
+
+export async function deletePurchaseBySubscriptionId(subscriptionId: string) {
+	await db
+		.delete(purchase)
+		.where(eq(purchase.subscriptionId, subscriptionId));
+}

packages/database/drizzle/queries/users.ts

@@ -0,0 +1,112 @@
+import { eq } from "drizzle-orm";
+import type { z } from "zod";
+import { db } from "../client";
+import { account, user } from "../schema/postgres";
+import type { UserUpdateSchema } from "../zod";
+
+export async function getUsers({
+	limit,
+	offset,
+	query,
+}: {
+	limit: number;
+	offset: number;
+	query?: string;
+}) {
+	return await db.query.user.findMany({
+		where: (user, { like }) => like(user.name, `%${query}%`),
+		limit,
+		offset,
+	});
+}
+
+export async function countAllUsers() {
+	return db.$count(user);
+}
+
+export async function getUserById(id: string) {
+	return await db.query.user.findFirst({
+		where: (user, { eq }) => eq(user.id, id),
+	});
+}
+
+export async function getUserByEmail(email: string) {
+	return await db.query.user.findFirst({
+		where: (user, { eq }) => eq(user.email, email),
+	});
+}
+
+export async function createUser({
+	email,
+	name,
+	role,
+	emailVerified,
+	onboardingComplete,
+}: {
+	email: string;
+	name: string;
+	role: "admin" | "user";
+	emailVerified: boolean;
+	onboardingComplete: boolean;
+}) {
+	const [{ id }] = await db
+		.insert(user)
+		.values({
+			email,
+			name,
+			role,
+			emailVerified,
+			onboardingComplete,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		})
+		.returning({
+			id: user.id,
+		});
+
+	const newUser = await getUserById(id);
+
+	return newUser;
+}
+
+export async function getAccountById(id: string) {
+	return await db.query.account.findFirst({
+		where: (account, { eq }) => eq(account.id, id),
+	});
+}
+
+export async function createUserAccount({
+	userId,
+	providerId,
+	accountId,
+	hashedPassword,
+}: {
+	userId: string;
+	providerId: string;
+	accountId: string;
+	hashedPassword?: string;
+}) {
+	const [{ id }] = await db
+		.insert(account)
+		.values({
+			userId,
+			accountId,
+			providerId,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+			password: hashedPassword,
+		})
+		.returning({
+			id: account.id,
+		});
+
+	const newAccount = await getAccountById(id);
+
+	return newAccount;
+}
+
+export async function updateUser(
+	updatedUser: z.infer<typeof UserUpdateSchema>,
+) {
+	return db.update(user).set(updatedUser).where(eq(user.id, updatedUser.id));
+}

packages/database/drizzle/schema/index.ts

@@ -0,0 +1 @@
+export * from "./sqlite";

packages/database/drizzle/schema/mysql.ts

@@ -0,0 +1,226 @@
+import { createId as cuid } from "@paralleldrive/cuid2";
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	int,
+	json,
+	mysqlEnum,
+	mysqlTable,
+	text,
+	timestamp,
+	uniqueIndex,
+	varchar,
+} from "drizzle-orm/mysql-core";
+
+// Enums
+export const purchaseTypeEnum = mysqlEnum("PurchaseType", [
+	"SUBSCRIPTION",
+	"ONE_TIME",
+]);
+
+// Tables
+export const user = mysqlTable("user", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	name: text("name").notNull(),
+	email: text("email").notNull().unique(),
+	emailVerified: boolean("emailVerified").notNull().default(false),
+	image: text("image"),
+	createdAt: timestamp("createdAt").notNull().defaultNow(),
+	updatedAt: timestamp("updatedAt").notNull().defaultNow(),
+	username: text("username").unique(),
+	role: text("role"),
+	banned: boolean("banned"),
+	banReason: text("banReason"),
+	banExpires: timestamp("banExpires"),
+	onboardingComplete: boolean("onboardingComplete").default(false).notNull(),
+	paymentsCustomerId: text("paymentsCustomerId"),
+	locale: text("locale"),
+});
+
+export const session = mysqlTable(
+	"session",
+	{
+		id: varchar("id", { length: 255 })
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		expiresAt: timestamp("expiresAt").notNull(),
+		ipAddress: text("ipAddress"),
+		userAgent: text("userAgent"),
+		userId: text("userId")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		impersonatedBy: text("impersonatedBy"),
+		activeOrganizationId: text("activeOrganizationId"),
+		token: text("token").notNull(),
+		createdAt: timestamp("createdAt").notNull(),
+		updatedAt: timestamp("updatedAt").notNull(),
+	},
+	(table) => [uniqueIndex("session_token_idx").on(table.token)],
+);
+
+export const account = mysqlTable("account", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	accountId: text("accountId").notNull(),
+	providerId: text("providerId").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	accessToken: text("accessToken"),
+	refreshToken: text("refreshToken"),
+	idToken: text("idToken"),
+	expiresAt: timestamp("expiresAt"),
+	password: text("password"),
+	accessTokenExpiresAt: timestamp("accessTokenExpiresAt"),
+	refreshTokenExpiresAt: timestamp("refreshTokenExpiresAt"),
+	scope: text("scope"),
+	createdAt: timestamp("createdAt").notNull(),
+	updatedAt: timestamp("updatedAt").notNull(),
+});
+
+export const verification = mysqlTable("verification", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	identifier: text("identifier").notNull(),
+	value: text("value").notNull(),
+	expiresAt: timestamp("expiresAt").notNull(),
+	createdAt: timestamp("createdAt"),
+	updatedAt: timestamp("updatedAt"),
+});
+
+export const passkey = mysqlTable("passkey", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	name: text("name"),
+	publicKey: text("publicKey").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	credentialID: text("credentialID").notNull(),
+	counter: int("counter").notNull(),
+	deviceType: text("deviceType").notNull(),
+	backedUp: boolean("backedUp").notNull(),
+	transports: text("transports"),
+	createdAt: timestamp("createdAt"),
+});
+
+export const twoFactor = mysqlTable("twoFactor", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	secret: text("secret").notNull(),
+	backupCodes: text("backupCodes").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const organization = mysqlTable(
+	"organization",
+	{
+		id: text("id").primaryKey(),
+		name: text("name").notNull(),
+		slug: text("slug"),
+		logo: text("logo"),
+		createdAt: timestamp("createdAt").notNull(),
+		metadata: text("metadata"),
+		paymentsCustomerId: text("paymentsCustomerId"),
+	},
+	(table) => [uniqueIndex("organization_slug_idx").on(table.slug)],
+);
+
+export const member = mysqlTable(
+	"member",
+	{
+		id: varchar("id", { length: 255 })
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		organizationId: text("organizationId")
+			.notNull()
+			.references(() => organization.id, { onDelete: "cascade" }),
+		userId: text("userId")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		role: text("role").notNull(),
+		createdAt: timestamp("createdAt").notNull(),
+	},
+	(table) => [
+		uniqueIndex("member_user_org_idx").on(
+			table.userId,
+			table.organizationId,
+		),
+	],
+);
+
+export const invitation = mysqlTable("invitation", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId")
+		.notNull()
+		.references(() => organization.id, { onDelete: "cascade" }),
+	email: text("email").notNull(),
+	role: text("role"),
+	status: text("status").notNull(),
+	expiresAt: timestamp("expiresAt").notNull(),
+	inviterId: text("inviterId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const purchase = mysqlTable("purchase", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId").references(() => organization.id, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => user.id, {
+		onDelete: "cascade",
+	}),
+	type: purchaseTypeEnum.notNull(),
+	customerId: text("customerId").notNull(),
+	subscriptionId: text("subscriptionId").unique(),
+	productId: text("productId").notNull(),
+	status: text("status"),
+	createdAt: timestamp("createdAt").defaultNow().notNull(),
+	updatedAt: timestamp("updatedAt"),
+});
+
+export const aiChat = mysqlTable("aiChat", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId").references(() => organization.id, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => user.id, { onDelete: "cascade" }),
+	title: text("title"),
+	messages: json("messages"),
+	createdAt: timestamp("createdAt").defaultNow().notNull(),
+	updatedAt: timestamp("updatedAt"),
+});
+
+// Relations
+export const userRelations = relations(user, ({ many }) => ({
+	sessions: many(session),
+	accounts: many(account),
+	passkeys: many(passkey),
+	invitations: many(invitation),
+	purchases: many(purchase),
+	memberships: many(member),
+	aiChats: many(aiChat),
+	twoFactors: many(twoFactor),
+}));
+
+export const organizationRelations = relations(organization, ({ many }) => ({
+	members: many(member),
+	invitations: many(invitation),
+	purchases: many(purchase),
+	aiChats: many(aiChat),
+}));

packages/database/drizzle/schema/postgres.ts

@@ -0,0 +1,235 @@
+import { createId as cuid } from "@paralleldrive/cuid2";
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	text,
+	timestamp,
+	uniqueIndex,
+	varchar,
+} from "drizzle-orm/pg-core";
+
+// Enums
+export const purchaseTypeEnum = pgEnum("PurchaseType", [
+	"SUBSCRIPTION",
+	"ONE_TIME",
+]);
+
+// Tables
+export const user = pgTable("user", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	name: text("name").notNull(),
+	email: text("email").notNull().unique(),
+	emailVerified: boolean("emailVerified").notNull().default(false),
+	image: text("image"),
+	createdAt: timestamp("createdAt").notNull().defaultNow(),
+	updatedAt: timestamp("updatedAt").notNull().defaultNow(),
+	username: text("username").unique(),
+	role: text("role"),
+	banned: boolean("banned"),
+	banReason: text("banReason"),
+	banExpires: timestamp("banExpires"),
+	onboardingComplete: boolean("onboardingComplete").default(false).notNull(),
+	paymentsCustomerId: text("paymentsCustomerId"),
+	locale: text("locale"),
+});
+
+export const session = pgTable(
+	"session",
+	{
+		id: varchar("id", { length: 255 })
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		expiresAt: timestamp("expiresAt").notNull(),
+		ipAddress: text("ipAddress"),
+		userAgent: text("userAgent"),
+		userId: text("userId")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		impersonatedBy: text("impersonatedBy"),
+		activeOrganizationId: text("activeOrganizationId"),
+		token: text("token").notNull(),
+		createdAt: timestamp("createdAt").notNull(),
+		updatedAt: timestamp("updatedAt").notNull(),
+	},
+	(table) => [uniqueIndex("session_token_idx").on(table.token)],
+);
+
+export const account = pgTable("account", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	accountId: text("accountId").notNull(),
+	providerId: text("providerId").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	accessToken: text("accessToken"),
+	refreshToken: text("refreshToken"),
+	idToken: text("idToken"),
+	expiresAt: timestamp("expiresAt"),
+	password: text("password"),
+	accessTokenExpiresAt: timestamp("accessTokenExpiresAt"),
+	refreshTokenExpiresAt: timestamp("refreshTokenExpiresAt"),
+	scope: text("scope"),
+	createdAt: timestamp("createdAt").notNull(),
+	updatedAt: timestamp("updatedAt").notNull(),
+});
+
+export const verification = pgTable("verification", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	identifier: text("identifier").notNull(),
+	value: text("value").notNull(),
+	expiresAt: timestamp("expiresAt").notNull(),
+	createdAt: timestamp("createdAt"),
+	updatedAt: timestamp("updatedAt"),
+});
+
+export const passkey = pgTable("passkey", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	name: text("name"),
+	publicKey: text("publicKey").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	credentialID: text("credentialID").notNull(),
+	counter: integer("counter").notNull(),
+	deviceType: text("deviceType").notNull(),
+	backedUp: boolean("backedUp").notNull(),
+	transports: text("transports"),
+	createdAt: timestamp("createdAt"),
+});
+
+export const twoFactor = pgTable("twoFactor", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	secret: text("secret").notNull(),
+	backupCodes: text("backupCodes").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const organization = pgTable(
+	"organization",
+	{
+		id: varchar("id", { length: 255 })
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		name: text("name").notNull(),
+		slug: text("slug"),
+		logo: text("logo"),
+		createdAt: timestamp("createdAt").notNull(),
+		metadata: text("metadata"),
+		paymentsCustomerId: text("paymentsCustomerId"),
+	},
+
+	(table) => [uniqueIndex("organization_slug_idx").on(table.slug)],
+);
+
+export const member = pgTable(
+	"member",
+	{
+		id: varchar("id", { length: 255 })
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		organizationId: text("organizationId")
+			.notNull()
+			.references(() => organization.id, { onDelete: "cascade" }),
+		userId: text("userId")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		role: text("role").notNull(),
+		createdAt: timestamp("createdAt").notNull(),
+	},
+	(table) => [
+		uniqueIndex("member_user_org_idx").on(
+			table.userId,
+			table.organizationId,
+		),
+	],
+);
+
+export const invitation = pgTable("invitation", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId")
+		.notNull()
+		.references(() => organization.id, { onDelete: "cascade" }),
+	email: text("email").notNull(),
+	role: text("role"),
+	status: text("status").notNull(),
+	expiresAt: timestamp("expiresAt").notNull(),
+	inviterId: text("inviterId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const purchase = pgTable("purchase", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId").references(() => organization.id, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => user.id, {
+		onDelete: "cascade",
+	}),
+	type: purchaseTypeEnum("type").notNull(),
+	customerId: text("customerId").notNull(),
+	subscriptionId: text("subscriptionId").unique(),
+	productId: text("productId").notNull(),
+	status: text("status"),
+	createdAt: timestamp("createdAt").defaultNow().notNull(),
+	updatedAt: timestamp("updatedAt"),
+});
+
+export const aiChat = pgTable("aiChat", {
+	id: varchar("id", { length: 255 })
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId").references(() => organization.id, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => user.id, { onDelete: "cascade" }),
+	title: text("title"),
+	messages:
+		json("messages").$type<
+			{
+				role: "user" | "assistant";
+				content: string;
+			}[]
+		>(),
+	createdAt: timestamp("createdAt").defaultNow().notNull(),
+	updatedAt: timestamp("updatedAt"),
+});
+
+// Relations
+export const userRelations = relations(user, ({ many }) => ({
+	sessions: many(session),
+	accounts: many(account),
+	passkeys: many(passkey),
+	invitations: many(invitation),
+	purchases: many(purchase),
+	memberships: many(member),
+	aiChats: many(aiChat),
+	twoFactors: many(twoFactor),
+}));
+
+export const organizationRelations = relations(organization, ({ many }) => ({
+	members: many(member),
+	invitations: many(invitation),
+	purchases: many(purchase),
+	aiChats: many(aiChat),
+}));

packages/database/drizzle/schema/sqlite.ts

@@ -0,0 +1,235 @@
+import { createId as cuid } from "@paralleldrive/cuid2";
+import { relations, sql } from "drizzle-orm";
+import {
+	blob,
+	integer,
+	sqliteTable,
+	text,
+	uniqueIndex,
+} from "drizzle-orm/sqlite-core";
+// Tables
+export const user = sqliteTable("user", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	name: text("name").notNull(),
+	email: text("email").notNull().unique(),
+	emailVerified: integer("emailVerified", { mode: "boolean" })
+		.notNull()
+		.default(false),
+	image: text("image"),
+	createdAt: integer("createdAt", { mode: "timestamp" })
+		.notNull()
+		.default(sql`CURRENT_TIMESTAMP`),
+	updatedAt: integer("updatedAt", { mode: "timestamp" })
+		.notNull()
+		.default(sql`CURRENT_TIMESTAMP`),
+	username: text("username").unique(),
+	role: text("role"),
+	banned: integer("banned", { mode: "boolean" }),
+	banReason: text("banReason"),
+	banExpires: integer("banExpires", { mode: "timestamp" }),
+	onboardingComplete: integer("onboardingComplete", { mode: "boolean" })
+		.notNull()
+		.default(false),
+	paymentsCustomerId: text("paymentsCustomerId"),
+	locale: text("locale"),
+});
+
+export const session = sqliteTable(
+	"session",
+	{
+		id: text("id")
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		expiresAt: integer("expiresAt", { mode: "timestamp" }).notNull(),
+		ipAddress: text("ipAddress"),
+		userAgent: text("userAgent"),
+		userId: text("userId")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		impersonatedBy: text("impersonatedBy"),
+		activeOrganizationId: text("activeOrganizationId"),
+		token: text("token").notNull(),
+		createdAt: integer("createdAt", { mode: "timestamp" }).notNull(),
+		updatedAt: integer("updatedAt", { mode: "timestamp" }).notNull(),
+	},
+	(table) => [uniqueIndex("session_token_idx").on(table.token)],
+);
+
+export const account = sqliteTable("account", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	accountId: text("accountId").notNull(),
+	providerId: text("providerId").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	accessToken: text("accessToken"),
+	refreshToken: text("refreshToken"),
+	idToken: text("idToken"),
+	expiresAt: integer("expiresAt", { mode: "timestamp" }),
+	password: text("password"),
+	accessTokenExpiresAt: integer("accessTokenExpiresAt", {
+		mode: "timestamp",
+	}),
+	refreshTokenExpiresAt: integer("refreshTokenExpiresAt", {
+		mode: "timestamp",
+	}),
+	scope: text("scope"),
+	createdAt: integer("createdAt", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updatedAt", { mode: "timestamp" }).notNull(),
+});
+
+export const verification = sqliteTable("verification", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	identifier: text("identifier").notNull(),
+	value: text("value").notNull(),
+	expiresAt: integer("expiresAt", { mode: "timestamp" }).notNull(),
+	createdAt: integer("createdAt", { mode: "timestamp" }),
+	updatedAt: integer("updatedAt", { mode: "timestamp" }),
+});
+
+export const passkey = sqliteTable("passkey", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	name: text("name"),
+	publicKey: text("publicKey").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	credentialID: text("credentialID").notNull(),
+	counter: integer("counter").notNull(),
+	deviceType: text("deviceType").notNull(),
+	backedUp: integer("backedUp", { mode: "boolean" }).notNull(),
+	transports: text("transports"),
+	createdAt: integer("createdAt", { mode: "timestamp" }),
+});
+
+export const twoFactor = sqliteTable("twoFactor", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	secret: text("secret").notNull(),
+	backupCodes: text("backupCodes").notNull(),
+	userId: text("userId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const organization = sqliteTable(
+	"organization",
+	{
+		id: text("id")
+			.$defaultFn(() => cuid())
+			.primaryKey(),
+		name: text("name").notNull(),
+		slug: text("slug"),
+		logo: text("logo"),
+		createdAt: integer("createdAt", { mode: "timestamp" }).notNull(),
+		metadata: text("metadata"),
+		paymentsCustomerId: text("paymentsCustomerId"),
+	},
+	(table) => [uniqueIndex("organization_slug_idx").on(table.slug)],
+);
+
+export const member = sqliteTable(
+	"member",
+	{
+		id: text("id").primaryKey(),
+		organizationId: text("organizationId")
+			.notNull()
+			.references(() => organization.id, { onDelete: "cascade" }),
+		userId: text("userId")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		role: text("role").notNull(),
+		createdAt: integer("createdAt", { mode: "timestamp" }).notNull(),
+	},
+	(table) => [
+		uniqueIndex("member_user_org_idx").on(
+			table.userId,
+			table.organizationId,
+		),
+	],
+);
+
+export const invitation = sqliteTable("invitation", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId")
+		.notNull()
+		.references(() => organization.id, { onDelete: "cascade" }),
+	email: text("email").notNull(),
+	role: text("role"),
+	status: text("status").notNull(),
+	expiresAt: integer("expiresAt", { mode: "timestamp" }).notNull(),
+	inviterId: text("inviterId")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const purchase = sqliteTable("purchase", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId").references(() => organization.id, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => user.id, {
+		onDelete: "cascade",
+	}),
+	type: text({ enum: ["SUBSCRIPTION", "ONE_TIME"] }).notNull(),
+	customerId: text("customerId").notNull(),
+	subscriptionId: text("subscriptionId").unique(),
+	productId: text("productId").notNull(),
+	status: text("status"),
+	createdAt: integer("createdAt", { mode: "timestamp" })
+		.notNull()
+		.default(sql`CURRENT_TIMESTAMP`),
+	updatedAt: integer("updatedAt", { mode: "timestamp" }).default(
+		sql`CURRENT_TIMESTAMP`,
+	),
+});
+
+export const aiChat = sqliteTable("aiChat", {
+	id: text("id")
+		.$defaultFn(() => cuid())
+		.primaryKey(),
+	organizationId: text("organizationId").references(() => organization.id, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => user.id, { onDelete: "cascade" }),
+	title: text("title"),
+	messages: blob("messages", { mode: "json" }),
+	createdAt: integer("createdAt", { mode: "timestamp" })
+		.notNull()
+		.default(sql`CURRENT_TIMESTAMP`),
+	updatedAt: integer("updatedAt", { mode: "timestamp" }).default(
+		sql`CURRENT_TIMESTAMP`,
+	),
+});
+
+// Relations
+export const userRelations = relations(user, ({ many }) => ({
+	sessions: many(session),
+	accounts: many(account),
+	passkeys: many(passkey),
+	invitations: many(invitation),
+	purchases: many(purchase),
+	memberships: many(member),
+	aiChats: many(aiChat),
+	twoFactors: many(twoFactor),
+}));
+
+export const organizationRelations = relations(organization, ({ many }) => ({
+	members: many(member),
+	invitations: many(invitation),
+	purchases: many(purchase),
+	aiChats: many(aiChat),
+}));

packages/database/drizzle/zod.ts

@@ -0,0 +1,40 @@
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+} from "drizzle-zod";
+import { z } from "zod";
+import {
+	account,
+	aiChat,
+	invitation,
+	member,
+	organization,
+	passkey,
+	purchase,
+	session,
+	user,
+	verification,
+} from "./schema";
+
+export const AiChatSchema = createSelectSchema(aiChat);
+export const UserSchema = createSelectSchema(user);
+export const UserUpdateSchema = createUpdateSchema(user, {
+	id: z.string(),
+});
+export const OrganizationSchema = createSelectSchema(organization);
+export const OrganizationUpdateSchema = createUpdateSchema(organization, {
+	id: z.string(),
+});
+export const MemberSchema = createSelectSchema(member);
+export const InvitationSchema = createSelectSchema(invitation);
+export const PurchaseSchema = createSelectSchema(purchase);
+export type Purchase = typeof purchase.$inferSelect;
+export const PurchaseInsertSchema = createInsertSchema(purchase);
+export const PurchaseUpdateSchema = createUpdateSchema(purchase, {
+	id: z.string(),
+});
+export const SessionSchema = createSelectSchema(session);
+export const AccountSchema = createSelectSchema(account);
+export const VerificationSchema = createSelectSchema(verification);
+export const PasskeySchema = createSelectSchema(passkey);