feat(db): update drizzle version

packages/database/package.json

@@ -12,14 +12,14 @@
   "devDependencies": {
     "@types/bun": "latest",
     "@types/pg": "^8.11.10",
-    "drizzle-kit": "^0.24.2"
+    "drizzle-kit": "^0.27.1"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
   "dependencies": {
     "@boring.tools/logger": "workspace:*",
-    "drizzle-orm": "^0.33.0",
+    "drizzle-orm": "^0.36.0",
     "pg": "^8.13.0"
   }
 }

packages/database/src/schema/_basic.ts

@@ -0,0 +1,7 @@
+import { timestamp, uuid } from 'drizzle-orm/pg-core'
+
+export const _basic_schema = {
+  id: uuid().primaryKey(),
+  createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp({ withTimezone: true }),
+}

packages/database/src/schema/access_token.ts

@@ -1,16 +1,17 @@
 import { relations } from 'drizzle-orm'
 import { pgTable, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core'
 import { user } from '.'
+import { _basic_schema } from './_basic'
 
 export const access_token = pgTable('access_token', {
-  id: uuid('id').primaryKey().defaultRandom(),
+  ..._basic_schema,
-  userId: varchar('userId', { length: 32 }).references(() => user.id, {
+
+  userId: varchar({ length: 32 }).references(() => user.id, {
     onDelete: 'cascade',
   }),
-  token: text('token').notNull(),
+  token: text().notNull(),
-  name: text('name').notNull(),
+  name: text().notNull(),
-  createdAt: timestamp('createdAt').defaultNow().notNull(),
+  lastUsedOn: timestamp(),
-  lastUsedOn: timestamp('lastUsedOn'),
 })
 
 export const access_token_relation = relations(access_token, ({ one }) => ({

packages/database/src/schema/changelog.ts

@@ -11,33 +11,32 @@ import {
 } from 'drizzle-orm/pg-core'
 import { json } from 'drizzle-orm/pg-core'
 import { uniqueIndex } from 'drizzle-orm/pg-core'
+import { _basic_schema } from './_basic'
 import { page } from './page'
 import { user } from './user'
 
 export const changelog = pgTable('changelog', {
-  id: uuid('id').primaryKey().defaultRandom(),
+  ..._basic_schema,
-  createdAt: timestamp('createdAt').defaultNow(),
-  updatedAt: timestamp('updatedAt'),
 
-  userId: varchar('userId', { length: 32 }).references(() => user.id, {
+  userId: varchar({ length: 32 }).references(() => user.id, {
     onDelete: 'cascade',
   }),
 
-  pageId: uuid('pageId').references(() => page.id),
+  pageId: uuid().references(() => page.id),
 
-  title: varchar('title', { length: 256 }),
+  title: varchar({ length: 256 }),
-  description: text('description'),
+  description: text(),
-  isSemver: boolean('isSemver').default(true),
+  isSemver: boolean().default(true),
-  isConventional: boolean('isConventional').default(true),
+  isConventional: boolean().default(true),
 })
 
 export const changelogs_to_pages = pgTable(
   'changelogs_to_pages',
   {
-    changelogId: uuid('changelogId')
+    changelogId: uuid()
       .notNull()
       .references(() => changelog.id, { onDelete: 'cascade' }),
-    pageId: uuid('pageId')
+    pageId: uuid()
       .notNull()
       .references(() => page.id, { onDelete: 'cascade' }),
   },
@@ -77,50 +76,50 @@ export const changelog_version_status = pgEnum('status', [
 ])
 
 export const changelog_version = pgTable('changelog_version', {
-  id: uuid('id').primaryKey().defaultRandom(),
+  id: uuid().primaryKey().defaultRandom(),
-  createdAt: timestamp('createdAt').defaultNow(),
+  createdAt: timestamp().defaultNow(),
-  updatedAt: timestamp('updatedAt'),
+  updatedAt: timestamp(),
-  releasedAt: timestamp('releasedAt'),
+  releasedAt: timestamp(),
 
-  changelogId: uuid('changelogId')
+  changelogId: uuid()
     .references(() => changelog.id, {
       onDelete: 'cascade',
     })
     .notNull(),
 
-  version: varchar('version', { length: 32 }).notNull(),
+  version: varchar({ length: 32 }).notNull(),
-  markdown: text('markdown').notNull(),
+  markdown: text().notNull(),
-  status: changelog_version_status('status').default('draft').notNull(),
+  status: changelog_version_status().default('draft').notNull(),
 })
 
 export const changelog_commit = pgTable(
   'changelog_commit',
   {
-    id: uuid('id').primaryKey().defaultRandom(),
+    id: uuid().primaryKey().defaultRandom(),
-    createdAt: timestamp('createdAt'),
+    createdAt: timestamp(),
 
-    changelogId: uuid('changelogId').references(() => changelog.id, {
+    changelogId: uuid().references(() => changelog.id, {
       onDelete: 'cascade',
     }),
-    versionId: uuid('versionId').references(() => changelog_version.id, {
+    versionId: uuid().references(() => changelog_version.id, {
       onUpdate: 'set null',
     }),
 
-    commit: varchar('commit', { length: 8 }).notNull(),
+    commit: varchar({ length: 8 }).notNull(),
-    parent: varchar('parent', { length: 8 }),
+    parent: varchar({ length: 8 }),
-    subject: text('subject').notNull(),
+    subject: text().notNull(),
-    author: json('author').$type<{
+    author: json().$type<{
       name: string
       email: string
       date: string
     }>(),
-    commiter: json('comitter').$type<{
+    commiter: json().$type<{
       name: string
       email: string
       date: string
     }>(),
 
-    body: text('body'),
+    body: text(),
   },
   (table) => ({
     unique: uniqueIndex('unique').on(table.changelogId, table.commit),

packages/database/src/schema/page.ts

@@ -1,18 +1,19 @@
 import { relations } from 'drizzle-orm'
 import { pgTable, text, uuid, varchar } from 'drizzle-orm/pg-core'
-import { changelog, changelogs_to_pages } from './changelog'
+import { _basic_schema } from './_basic'
+import { changelogs_to_pages } from './changelog'
 import { user } from './user'
 
 export const page = pgTable('page', {
-  id: uuid('id').primaryKey().defaultRandom(),
+  ..._basic_schema,
 
-  userId: varchar('userId', { length: 32 }).references(() => user.id, {
+  userId: varchar({ length: 32 }).references(() => user.id, {
     onDelete: 'cascade',
   }),
 
-  title: text('title').notNull(),
+  title: text().notNull(),
-  description: text('description').notNull(),
+  description: text().notNull(),
-  icon: text('icon').default(''),
+  icon: text().default(''),
 })
 
 export const pageRelation = relations(page, ({ many }) => ({

packages/database/src/schema/user.ts

@@ -4,9 +4,9 @@ import { access_token } from '.'
 import { changelog } from './changelog'
 
 export const user = pgTable('user', {
-  id: varchar('id', { length: 32 }).primaryKey(), // Clerk User Id
+  id: varchar({ length: 32 }).primaryKey(), // Clerk User Id
-  name: text('name'),
+  name: text(),
-  email: text('email').notNull().unique(),
+  email: text().notNull().unique(),
 })
 
 export const userRelation = relations(user, ({ many }) => ({