Merge pull request #29 from dcramer/feat/upgrade-drizzle

Upgrade Drizzle

apps/api/package.json

@@ -21,13 +21,9 @@
  "@fastify/multipart": "^7.6.0",
  "@fastify/one-line-logger": "^1.1.1",
  "@google-cloud/storage": "^6.10.1",
- "@opentelemetry/api": "^1.4.1",
- "@opentelemetry/auto-instrumentations-node": "^0.36.6",
- "@opentelemetry/sdk-node": "^0.38.0",
  "@paralleldrive/cuid2": "^2.2.0",
  "@peated/shared": "workspace:*",
  "@sentry/node": "^7.51.0",
- "@sentry/opentelemetry-node": "^7.51.0",
  "@sentry/profiling-node": "^0.3.0",
  "@sentry/utils": "^7.51.0",
  "@swc/core": "^1.3.57",
@@ -41,8 +37,8 @@
  "commander": "^10.0.1",
  "dotenv": "^16.0.3",
  "dotenv-cli": "^7.1.0",
- "drizzle-kit": "^0.17.6",
- "drizzle-orm": "^0.25.4",
+ "drizzle-kit": "^0.18.0",
+ "drizzle-orm": "^0.26.0",
  "fastify": "^4.15.0",
  "fastify-plugin": "^4.5.0",
  "form-data-encoder": "^2.1.4",

apps/api/src/db/index.ts

@@ -1,6 +1,9 @@
-import { drizzle } from "drizzle-orm/node-postgres";
+import { ExtractTablesWithRelations } from "drizzle-orm";
+import { NodePgQueryResultHKT, drizzle } from "drizzle-orm/node-postgres";
+import { PgTransaction } from "drizzle-orm/pg-core";
 import { Pool } from "pg";
 import config from "../config";
+import * as schema from "./schema";
 
 declare global {
  interface BigInt {
@@ -16,23 +19,12 @@ export const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
 });
 
-export const db = drizzle(pool, { logger: config.DEBUG });
+export const db = drizzle(pool, { logger: config.DEBUG, schema });
 
-export function first<T>(value: T[]): T | undefined {
- const [result] = value;
- return result;
-}
+export type DatabaseType = typeof db;
 
-// export const findFirst = async (
-// table: AnyPgTable,
-// query: {
-// [name: string]: any;
-// }
-// ) => {
-// const [{ result }] = await db
-// .select({ result: table })
-// .from(table)
-// .where(and(...Object.entries(query).map(([k, v]) => eq(table[k], v))))
-// .limit(1);
-// return result;
-// };
+export type TransactionType = PgTransaction<
+ NodePgQueryResultHKT,
+ typeof schema,
+ ExtractTablesWithRelations<typeof schema>
+>;

apps/api/src/db/migrate.ts

@@ -1,13 +1,13 @@
 import { sql } from "drizzle-orm";
 import { readMigrationFiles } from "drizzle-orm/migrator";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { DatabaseType } from ".";
 
 export const migrate = async function ({
  db,
  fake = false,
  migrationsFolder = "./migrations",
 }: {
- db: NodePgDatabase;
+ db: DatabaseType;
  fake?: boolean;
  migrationsFolder?: string;
 }) {

apps/api/src/db/schema.ts

@@ -1,4 +1,4 @@
-import { InferModel } from "drizzle-orm";
+import { InferModel, relations } from "drizzle-orm";
 import {
  bigint,
  bigserial,
@@ -65,6 +65,13 @@ export const identities = pgTable(
  },
 );
 
+export const identitiesRelations = relations(identities, ({ one }) => ({
+ user: one(users, {
+ fields: [identities.userId],
+ references: [users.id],
+ }),
+}));
+
 export const followStatusEnum = pgEnum("follow_status", [
  "none",
  "pending",
@@ -94,6 +101,17 @@ export const follows = pgTable(
  },
 );
 
+export const followsRelations = relations(follows, ({ one, many }) => ({
+ fromUser: one(users, {
+ fields: [follows.fromUserId],
+ references: [users.id],
+ }),
+ toUser: one(users, {
+ fields: [follows.toUserId],
+ references: [users.id],
+ }),
+}));
+
 export type Follow = InferModel<typeof follows>;
 export type NewFollow = InferModel<typeof follows, "insert">;
 
@@ -134,6 +152,15 @@ export const entities = pgTable(
  },
 );
 
+export const entitiesRelations = relations(entities, ({ one, many }) => ({
+ distillersToBottles: many(bottlesToDistillers),
+ brandsToBottles: many(bottles),
+ createdBy: one(users, {
+ fields: [entities.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Entity = InferModel<typeof entities>;
 export type NewEntity = InferModel<typeof entities, "insert">;
 
@@ -185,6 +212,18 @@ export const bottles = pgTable(
  },
 );
 
+export const bottlesRelations = relations(bottles, ({ one, many }) => ({
+ brand: one(entities, {
+ fields: [bottles.brandId],
+ references: [entities.id],
+ }),
+ bottlesToDistillers: many(bottlesToDistillers),
+ createdBy: one(users, {
+ fields: [bottles.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Bottle = InferModel<typeof bottles>;
 export type NewBottle = InferModel<typeof bottles, "insert">;
 
@@ -208,6 +247,20 @@ export const bottlesToDistillers = pgTable(
  },
 );
 
+export const bottlesToDistillersRelations = relations(
+ bottlesToDistillers,
+ ({ one }) => ({
+ bottle: one(bottles, {
+ fields: [bottlesToDistillers.bottleId],
+ references: [bottles.id],
+ }),
+ distiller: one(entities, {
+ fields: [bottlesToDistillers.distillerId],
+ references: [entities.id],
+ }),
+ }),
+);
+
 export const collections = pgTable(
  "collection",
  {
@@ -231,6 +284,14 @@ export const collections = pgTable(
  },
 );
 
+export const collectionsRelations = relations(collections, ({ one, many }) => ({
+ collectionBottles: many(collectionBottles),
+ createdBy: one(users, {
+ fields: [collections.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Collection = InferModel<typeof collections>;
 export type NewCollection = InferModel<typeof collections, "insert">;
 
@@ -261,6 +322,20 @@ export const collectionBottles = pgTable(
  },
 );
 
+export const collectionBottlesRelations = relations(
+ collectionBottles,
+ ({ one }) => ({
+ collection: one(collections, {
+ fields: [collectionBottles.collectionId],
+ references: [collections.id],
+ }),
+ bottle: one(bottles, {
+ fields: [collectionBottles.bottleId],
+ references: [bottles.id],
+ }),
+ }),
+);
+
 export type CollectionBottle = InferModel<typeof collectionBottles>;
 export type NewCollectionBottle = InferModel<
  typeof collectionBottles,
@@ -303,6 +378,17 @@ export const tastings = pgTable(
  },
 );
 
+export const tastingsRelations = relations(tastings, ({ one }) => ({
+ bottle: one(bottles, {
+ fields: [tastings.bottleId],
+ references: [bottles.id],
+ }),
+ createdBy: one(users, {
+ fields: [tastings.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Tasting = InferModel<typeof tastings>;
 export type NewTasting = InferModel<typeof tastings, "insert">;
 
@@ -328,6 +414,17 @@ export const toasts = pgTable(
  },
 );
 
+export const toastsRelations = relations(toasts, ({ one }) => ({
+ tasting: one(tastings, {
+ fields: [toasts.tastingId],
+ references: [tastings.id],
+ }),
+ createdBy: one(users, {
+ fields: [toasts.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Toast = InferModel<typeof toasts>;
 export type NewToast = InferModel<typeof toasts, "insert">;
 
@@ -356,6 +453,17 @@ export const comments = pgTable(
  },
 );
 
+export const commentsRelations = relations(comments, ({ one }) => ({
+ tasting: one(tastings, {
+ fields: [comments.tastingId],
+ references: [tastings.id],
+ }),
+ createdBy: one(users, {
+ fields: [comments.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Comment = InferModel<typeof comments>;
 export type NewComment = InferModel<typeof comments, "insert">;
 
@@ -390,6 +498,13 @@ export const changes = pgTable("change", {
  .notNull(),
 });
 
+export const changesRelations = relations(changes, ({ one }) => ({
+ createdBy: one(users, {
+ fields: [changes.createdById],
+ references: [users.id],
+ }),
+}));
+
 export type Change = InferModel<typeof changes>;
 export type NewChange = InferModel<typeof changes, "insert">;
 
@@ -424,5 +539,16 @@ export const notifications = pgTable(
  },
 );
 
+export const notificationsRelations = relations(notifications, ({ one }) => ({
+ user: one(users, {
+ fields: [notifications.userId],
+ references: [users.id],
+ }),
+ fromUser: one(users, {
+ fields: [notifications.fromUserId],
+ references: [users.id],
+ }),
+}));
+
 export type Notification = InferModel<typeof notifications>;
 export type NewNotification = InferModel<typeof notifications, "insert">;

apps/api/src/lib/auth.ts

@@ -1,6 +1,6 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { sign, verify } from "jsonwebtoken";
 import config from "../config";
+import { DatabaseType, TransactionType } from "../db";
 import { NewUser, User, users } from "../db/schema";
 import { random } from "./rand";
 import { serialize } from "./serializers";
@@ -39,7 +39,7 @@ export const verifyToken = (token: string | undefined): Promise<any> => {
 };
 
 export const createUser = async (
- db: NodePgDatabase,
+ db: DatabaseType | TransactionType,
  data: NewUser,
 ): Promise<User> => {
  let user: User | undefined;