@coursebuilder/adapter-drizzle 0.0.3 → 0.0.5

package/src/lib/sqlite.ts

@@ -1,12 +1,12 @@
 import type { AdapterAccount } from '@auth/core/adapters'
 import { and, eq, sql } from 'drizzle-orm'
 import {
-  BaseSQLiteDatabase,
-  sqliteTable as defaultSqliteTableFn,
-  integer,
-  primaryKey,
-  SQLiteTableFn,
-  text,
+	BaseSQLiteDatabase,
+	sqliteTable as defaultSqliteTableFn,
+	integer,
+	primaryKey,
+	SQLiteTableFn,
+	text,
 } from 'drizzle-orm/sqlite-core'
 
 import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
@@ -14,214 +14,274 @@ import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
 import { stripUndefined } from './utils.js'
 
 export function createTables(sqliteTable: SQLiteTableFn) {
-  const users = sqliteTable('user', {
-    id: text('id').notNull().primaryKey(),
-    name: text('name'),
-    role: text('role', { enum: ['user', 'admin'] }).default('user'),
-    email: text('email').notNull(),
-    emailVerified: integer('emailVerified', { mode: 'timestamp_ms' }),
-    image: text('image'),
-  })
+	const users = sqliteTable('user', {
+		id: text('id').notNull().primaryKey(),
+		name: text('name'),
+		role: text('role', { enum: ['user', 'admin'] }).default('user'),
+		email: text('email').notNull(),
+		emailVerified: integer('emailVerified', { mode: 'timestamp_ms' }),
+		image: text('image'),
+	})
 
-  const accounts = sqliteTable(
-    'account',
-    {
-      userId: text('userId')
-        .notNull()
-        .references(() => users.id, { onDelete: 'cascade' }),
-      type: text('type').$type<AdapterAccount['type']>().notNull(),
-      provider: text('provider').notNull(),
-      providerAccountId: text('providerAccountId').notNull(),
-      refresh_token: text('refresh_token'),
-      access_token: text('access_token'),
-      expires_at: integer('expires_at'),
-      token_type: text('token_type'),
-      scope: text('scope'),
-      id_token: text('id_token'),
-      session_state: text('session_state'),
-    },
-    (account) => ({
-      pk: primaryKey({ columns: [account.provider, account.providerAccountId] }),
-    }),
-  )
+	const accounts = sqliteTable(
+		'account',
+		{
+			userId: text('userId')
+				.notNull()
+				.references(() => users.id, { onDelete: 'cascade' }),
+			type: text('type').$type<AdapterAccount['type']>().notNull(),
+			provider: text('provider').notNull(),
+			providerAccountId: text('providerAccountId').notNull(),
+			refresh_token: text('refresh_token'),
+			access_token: text('access_token'),
+			expires_at: integer('expires_at'),
+			token_type: text('token_type'),
+			scope: text('scope'),
+			id_token: text('id_token'),
+			session_state: text('session_state'),
+		},
+		(account) => ({
+			pk: primaryKey({
+				columns: [account.provider, account.providerAccountId],
+			}),
+		}),
+	)
 
-  const sessions = sqliteTable('session', {
-    sessionToken: text('sessionToken').notNull().primaryKey(),
-    userId: text('userId')
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
-  })
+	const sessions = sqliteTable('session', {
+		sessionToken: text('sessionToken').notNull().primaryKey(),
+		userId: text('userId')
+			.notNull()
+			.references(() => users.id, { onDelete: 'cascade' }),
+		expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
+	})
 
-  const verificationTokens = sqliteTable(
-    'verificationToken',
-    {
-      identifier: text('identifier').notNull(),
-      token: text('token').notNull(),
-      expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
-    },
-    (vt) => ({
-      pk: primaryKey({ columns: [vt.identifier, vt.token] }),
-    }),
-  )
+	const verificationTokens = sqliteTable(
+		'verificationToken',
+		{
+			identifier: text('identifier').notNull(),
+			token: text('token').notNull(),
+			expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
+		},
+		(vt) => ({
+			pk: primaryKey({ columns: [vt.identifier, vt.token] }),
+		}),
+	)
 
-  const contentResource = sqliteTable('contentResource', {
-    id: text('id', { length: 255 }).notNull().primaryKey(),
-    type: text('type', { length: 255 }).notNull(),
-    createdById: text('createdById', { length: 255 }).notNull(),
-    fields: text('metadata', { mode: 'json' }).$type<Record<string, any>>().default({}),
-    createdAt: integer('createdAt', {
-      mode: 'timestamp_ms',
-    }).default(sql`CURRENT_TIME`),
-    updatedAt: integer('updatedAt', {
-      mode: 'timestamp_ms',
-    }).default(sql`CURRENT_TIME`),
-    deletedAt: integer('deletedAt', {
-      mode: 'timestamp_ms',
-    }),
-  })
+	const contentResource = sqliteTable('contentResource', {
+		id: text('id', { length: 255 }).notNull().primaryKey(),
+		type: text('type', { length: 255 }).notNull(),
+		createdById: text('createdById', { length: 255 }).notNull(),
+		fields: text('metadata', { mode: 'json' })
+			.$type<Record<string, any>>()
+			.default({}),
+		createdAt: integer('createdAt', {
+			mode: 'timestamp_ms',
+		}).default(sql`CURRENT_TIME`),
+		updatedAt: integer('updatedAt', {
+			mode: 'timestamp_ms',
+		}).default(sql`CURRENT_TIME`),
+		deletedAt: integer('deletedAt', {
+			mode: 'timestamp_ms',
+		}),
+	})
 
-  const contentResourceResource = sqliteTable(
-    'contentResourceResource',
-    {
-      resourceOfId: text('resourceOfId', { length: 255 }).notNull(),
-      resourceId: text('resourceId', { length: 255 }).notNull(),
-      position: integer('position').notNull().default(0),
-      metadata: text('metadata', { mode: 'json' }).$type<Record<string, any>>().default({}),
-      createdAt: integer('createdAt', {
-        mode: 'timestamp_ms',
-      }).default(sql`CURRENT_TIME`),
-      updatedAt: integer('updatedAt', {
-        mode: 'timestamp_ms',
-      }).default(sql`CURRENT_TIME`),
-      deletedAt: integer('deletedAt', {
-        mode: 'timestamp_ms',
-      }),
-    },
-    (crr) => ({
-      pk: primaryKey({ columns: [crr.resourceOfId, crr.resourceId] }),
-    }),
-  )
+	const contentResourceResource = sqliteTable(
+		'contentResourceResource',
+		{
+			resourceOfId: text('resourceOfId', { length: 255 }).notNull(),
+			resourceId: text('resourceId', { length: 255 }).notNull(),
+			position: integer('position').notNull().default(0),
+			metadata: text('metadata', { mode: 'json' })
+				.$type<Record<string, any>>()
+				.default({}),
+			createdAt: integer('createdAt', {
+				mode: 'timestamp_ms',
+			}).default(sql`CURRENT_TIME`),
+			updatedAt: integer('updatedAt', {
+				mode: 'timestamp_ms',
+			}).default(sql`CURRENT_TIME`),
+			deletedAt: integer('deletedAt', {
+				mode: 'timestamp_ms',
+			}),
+		},
+		(crr) => ({
+			pk: primaryKey({ columns: [crr.resourceOfId, crr.resourceId] }),
+		}),
+	)
 
-  return { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource }
+	return {
+		users,
+		accounts,
+		sessions,
+		verificationTokens,
+		contentResource,
+		contentResourceResource,
+	}
 }
 
 export type DefaultSchema = ReturnType<typeof createTables>
 
 export function SQLiteDrizzleAdapter(
-  client: InstanceType<typeof BaseSQLiteDatabase>,
-  tableFn = defaultSqliteTableFn,
+	client: InstanceType<typeof BaseSQLiteDatabase>,
+	tableFn = defaultSqliteTableFn,
 ): CourseBuilderAdapter {
-  const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn)
+	const { users, accounts, sessions, verificationTokens, contentResource } =
+		createTables(tableFn)
 
-  return {
-    async updateContentResourceFields(options) {
-      return null
-    },
-    async getVideoResource(id) {
-      //  TODO Implement
-      return null
-    },
-    async createContentResource(resource) {
-      return client
-        .insert(contentResource)
-        .values({ ...resource, id: crypto.randomUUID() })
-        .returning()
-        .get()
-    },
-    async getContentResource(data) {
-      const result = await client.select().from(contentResource).where(eq(contentResource.id, data)).get()
-      return result ?? null
-    },
-    async createUser(data) {
-      return client
-        .insert(users)
-        .values({ ...data, id: crypto.randomUUID() })
-        .returning()
-        .get()
-    },
-    async getUser(data) {
-      const result = await client.select().from(users).where(eq(users.id, data)).get()
-      return result ?? null
-    },
-    async getUserByEmail(data) {
-      const result = await client.select().from(users).where(eq(users.email, data)).get()
-      return result ?? null
-    },
-    createSession(data) {
-      return client.insert(sessions).values(data).returning().get()
-    },
-    async getSessionAndUser(data) {
-      const result = await client
-        .select({ session: sessions, user: users })
-        .from(sessions)
-        .where(eq(sessions.sessionToken, data))
-        .innerJoin(users, eq(users.id, sessions.userId))
-        .get()
-      return result ?? null
-    },
-    async updateUser(data) {
-      if (!data.id) {
-        throw new Error('No user id.')
-      }
+	return {
+		async updateContentResourceFields(options) {
+			return null
+		},
+		async getVideoResource(id) {
+			//  TODO Implement
+			return null
+		},
+		async createContentResource(resource) {
+			return client
+				.insert(contentResource)
+				.values({ ...resource, id: crypto.randomUUID() })
+				.returning()
+				.get()
+		},
+		async getContentResource(data) {
+			const result = await client
+				.select()
+				.from(contentResource)
+				.where(eq(contentResource.id, data))
+				.get()
+			return result ?? null
+		},
+		async createUser(data) {
+			return client
+				.insert(users)
+				.values({ ...data, id: crypto.randomUUID() })
+				.returning()
+				.get()
+		},
+		async getUser(data) {
+			const result = await client
+				.select()
+				.from(users)
+				.where(eq(users.id, data))
+				.get()
+			return result ?? null
+		},
+		async getUserByEmail(data) {
+			const result = await client
+				.select()
+				.from(users)
+				.where(eq(users.email, data))
+				.get()
+			return result ?? null
+		},
+		createSession(data) {
+			return client.insert(sessions).values(data).returning().get()
+		},
+		async getSessionAndUser(data) {
+			const result = await client
+				.select({ session: sessions, user: users })
+				.from(sessions)
+				.where(eq(sessions.sessionToken, data))
+				.innerJoin(users, eq(users.id, sessions.userId))
+				.get()
+			return result ?? null
+		},
+		async updateUser(data) {
+			if (!data.id) {
+				throw new Error('No user id.')
+			}
 
-      const result = await client.update(users).set(data).where(eq(users.id, data.id)).returning().get()
-      return result ?? null
-    },
-    async updateSession(data) {
-      const result = await client
-        .update(sessions)
-        .set(data)
-        .where(eq(sessions.sessionToken, data.sessionToken))
-        .returning()
-        .get()
-      return result ?? null
-    },
-    async linkAccount(rawAccount) {
-      return stripUndefined(await client.insert(accounts).values(rawAccount).returning().get())
-    },
-    async getUserByAccount(account) {
-      const results = await client
-        .select()
-        .from(accounts)
-        .leftJoin(users, eq(users.id, accounts.userId))
-        .where(and(eq(accounts.provider, account.provider), eq(accounts.providerAccountId, account.providerAccountId)))
-        .get()
+			const result = await client
+				.update(users)
+				.set(data)
+				.where(eq(users.id, data.id))
+				.returning()
+				.get()
+			return result ?? null
+		},
+		async updateSession(data) {
+			const result = await client
+				.update(sessions)
+				.set(data)
+				.where(eq(sessions.sessionToken, data.sessionToken))
+				.returning()
+				.get()
+			return result ?? null
+		},
+		async linkAccount(rawAccount) {
+			return stripUndefined(
+				await client.insert(accounts).values(rawAccount).returning().get(),
+			)
+		},
+		async getUserByAccount(account) {
+			const results = await client
+				.select()
+				.from(accounts)
+				.leftJoin(users, eq(users.id, accounts.userId))
+				.where(
+					and(
+						eq(accounts.provider, account.provider),
+						eq(accounts.providerAccountId, account.providerAccountId),
+					),
+				)
+				.get()
 
-      if (!results) {
-        return null
-      }
-      return Promise.resolve(results).then((results) => results.user)
-    },
-    async deleteSession(sessionToken) {
-      const result = await client.delete(sessions).where(eq(sessions.sessionToken, sessionToken)).returning().get()
-      return result ?? null
-    },
-    async createVerificationToken(token) {
-      const result = await client.insert(verificationTokens).values(token).returning().get()
-      return result ?? null
-    },
-    async useVerificationToken(token) {
-      try {
-        const result = await client
-          .delete(verificationTokens)
-          .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
-          .returning()
-          .get()
-        return result ?? null
-      } catch (err) {
-        throw new Error('No verification token found.')
-      }
-    },
-    async deleteUser(id) {
-      const result = await client.delete(users).where(eq(users.id, id)).returning().get()
-      return result ?? null
-    },
-    async unlinkAccount(account) {
-      await client
-        .delete(accounts)
-        .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)))
-        .run()
-    },
-  }
+			if (!results) {
+				return null
+			}
+			return Promise.resolve(results).then((results) => results.user)
+		},
+		async deleteSession(sessionToken) {
+			const result = await client
+				.delete(sessions)
+				.where(eq(sessions.sessionToken, sessionToken))
+				.returning()
+				.get()
+			return result ?? null
+		},
+		async createVerificationToken(token) {
+			const result = await client
+				.insert(verificationTokens)
+				.values(token)
+				.returning()
+				.get()
+			return result ?? null
+		},
+		async useVerificationToken(token) {
+			try {
+				const result = await client
+					.delete(verificationTokens)
+					.where(
+						and(
+							eq(verificationTokens.identifier, token.identifier),
+							eq(verificationTokens.token, token.token),
+						),
+					)
+					.returning()
+					.get()
+				return result ?? null
+			} catch (err) {
+				throw new Error('No verification token found.')
+			}
+		},
+		async deleteUser(id) {
+			const result = await client
+				.delete(users)
+				.where(eq(users.id, id))
+				.returning()
+				.get()
+			return result ?? null
+		},
+		async unlinkAccount(account) {
+			await client
+				.delete(accounts)
+				.where(
+					and(
+						eq(accounts.providerAccountId, account.providerAccountId),
+						eq(accounts.provider, account.provider),
+					),
+				)
+				.run()
+		},
+	}
 }

package/src/lib/utils.ts

@@ -5,7 +5,7 @@ import type { AnyPgTable, PgTableFn } from 'drizzle-orm/pg-core'
 import { type BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core'
 import type { AnySQLiteTable, SQLiteTableFn } from 'drizzle-orm/sqlite-core'
 
-import type { DefaultSchema as MySqlSchema } from './mysql.js'
+import type { DefaultSchema as MySqlSchema } from './mysql'
 import type { DefaultSchema as PgSchema } from './pg.js'
 import type { DefaultSchema as SQLiteSchema } from './sqlite.js'
 
@@ -14,35 +14,38 @@ export type AnyPgDatabase = PgDatabase<any, any, any>
 export type AnySQLiteDatabase = BaseSQLiteDatabase<any, any, any, any>
 
 export interface MinimumSchema {
-  mysql: MySqlSchema & Record<string, AnyMySqlTable>
-  pg: PgSchema & Record<string, AnyPgTable>
-  sqlite: SQLiteSchema & Record<string, AnySQLiteTable>
+	mysql: MySqlSchema & Record<string, AnyMySqlTable>
+	pg: PgSchema & Record<string, AnyPgTable>
+	sqlite: SQLiteSchema & Record<string, AnySQLiteTable>
 }
 
-export type SqlFlavorOptions = AnyMySqlDatabase | AnyPgDatabase | AnySQLiteDatabase
+export type SqlFlavorOptions =
+	| AnyMySqlDatabase
+	| AnyPgDatabase
+	| AnySQLiteDatabase
 
 export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase
-  ? MinimumSchema['mysql']
-  : Flavor extends AnyPgDatabase
-    ? MinimumSchema['pg']
-    : Flavor extends AnySQLiteDatabase
-      ? MinimumSchema['sqlite']
-      : never
+	? MinimumSchema['mysql']
+	: Flavor extends AnyPgDatabase
+		? MinimumSchema['pg']
+		: Flavor extends AnySQLiteDatabase
+			? MinimumSchema['sqlite']
+			: never
 
 export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase
-  ? MySqlTableFn
-  : Flavor extends AnyPgDatabase
-    ? PgTableFn
-    : Flavor extends AnySQLiteDatabase
-      ? SQLiteTableFn
-      : AnySQLiteTable
+	? MySqlTableFn
+	: Flavor extends AnyPgDatabase
+		? PgTableFn
+		: Flavor extends AnySQLiteDatabase
+			? SQLiteTableFn
+			: AnySQLiteTable
 
 type NonNullableProps<T> = {
-  [P in keyof T]: null extends T[P] ? never : P
+	[P in keyof T]: null extends T[P] ? never : P
 }[keyof T]
 
 export function stripUndefined<T>(obj: T): Pick<T, NonNullableProps<T>> {
-  const result = {} as T
-  for (const key in obj) if (obj[key] !== undefined) result[key] = obj[key]
-  return result
+	const result = {} as T
+	for (const key in obj) if (obj[key] !== undefined) result[key] = obj[key]
+	return result
 }

package/index.d.ts

@@ -1,6 +0,0 @@
-import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters';
-import { createTables as createMySqlTables } from './lib/mysql.js';
-import { type SqlFlavorOptions, type TableFn } from './lib/utils.js';
-export declare function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(db: SqlFlavor, table?: TableFn<SqlFlavor>): CourseBuilderAdapter;
-export { createMySqlTables };
-//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAExE,OAAO,EAAE,YAAY,IAAI,iBAAiB,EAAuB,MAAM,gBAAgB,CAAA;AAGvF,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAEpE,wBAAgB,cAAc,CAAC,SAAS,SAAS,gBAAgB,EAC/D,EAAE,EAAE,SAAS,EACb,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,GACzB,oBAAoB,CAUtB;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/index.js

@@ -1,20 +0,0 @@
-import { is } from 'drizzle-orm';
-import { MySqlDatabase } from 'drizzle-orm/mysql-core';
-import { PgDatabase } from 'drizzle-orm/pg-core';
-import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import { createTables as createMySqlTables, mySqlDrizzleAdapter } from './lib/mysql.js';
-import { pgDrizzleAdapter } from './lib/pg.js';
-import { SQLiteDrizzleAdapter } from './lib/sqlite.js';
-export function DrizzleAdapter(db, table) {
-    if (is(db, MySqlDatabase)) {
-        return mySqlDrizzleAdapter(db, table);
-    }
-    else if (is(db, PgDatabase)) {
-        return pgDrizzleAdapter(db, table);
-    }
-    else if (is(db, BaseSQLiteDatabase)) {
-        return SQLiteDrizzleAdapter(db, table);
-    }
-    throw new Error(`Unsupported database type (${typeof db}) in Auth.js Drizzle adapter.`);
-}
-export { createMySqlTables };