@coursebuilder/adapter-drizzle 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coursebuilder/adapter-drizzle",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Drizzle adapter for Course Builder.",
   "keywords": [
     "coursebuilder",
@@ -40,7 +40,7 @@
   },
   "devDependencies": {
     "@auth/core": "^0.28.1",
-    "@coursebuilder/core": "0.1.1",
+    "@coursebuilder/core": "0.1.4",
     "@libsql/client": "0.5.6",
     "@types/better-sqlite3": "7.6.9",
     "@types/uuid": "9.0.8",

package/src/index.ts

@@ -1,7 +1,5 @@
 import { is } from 'drizzle-orm'
 import { MySqlDatabase, type MySqlTableFn } from 'drizzle-orm/mysql-core'
-import { PgDatabase, type PgTableFn } from 'drizzle-orm/pg-core'
-import { BaseSQLiteDatabase, type SQLiteTableFn } from 'drizzle-orm/sqlite-core'
 
 import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
 
@@ -9,8 +7,6 @@ import {
 	createTables as createMySqlTables,
 	mySqlDrizzleAdapter,
 } from './lib/mysql/index.js'
-import { pgDrizzleAdapter } from './lib/pg.js'
-import { SQLiteDrizzleAdapter } from './lib/sqlite.js'
 import { type SqlFlavorOptions, type TableFn } from './lib/utils.js'
 
 export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
@@ -19,10 +15,6 @@ export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
 ): CourseBuilderAdapter {
 	if (is(db, MySqlDatabase)) {
 		return mySqlDrizzleAdapter(db, table as MySqlTableFn)
-	} else if (is(db, PgDatabase)) {
-		return pgDrizzleAdapter(db, table as PgTableFn)
-	} else if (is(db, BaseSQLiteDatabase)) {
-		return SQLiteDrizzleAdapter(db, table as SQLiteTableFn)
 	}
 
 	throw new Error(

package/src/lib/mysql/index.ts

@@ -19,8 +19,11 @@ import {
 	merchantCouponSchema,
 	MerchantCustomer,
 	MerchantProduct,
+	merchantProductSchema,
 	Price,
+	priceSchema,
 	Product,
+	productSchema,
 	Purchase,
 	purchaseSchema,
 	PurchaseUserTransfer,
@@ -79,7 +82,10 @@ import { getMerchantPriceSchema } from './schemas/commerce/merchant-price.js'
 import { getMerchantProductSchema } from './schemas/commerce/merchant-product.js'
 import { getMerchantSessionSchema } from './schemas/commerce/merchant-session.js'
 import { getPriceSchema } from './schemas/commerce/price.js'
-import { getProductSchema } from './schemas/commerce/product.js'
+import {
+	getProductRelationsSchema,
+	getProductSchema,
+} from './schemas/commerce/product.js'
 import { getPurchaseUserTransferSchema } from './schemas/commerce/purchase-user-transfer.js'
 import {
 	getPurchaseRelationsSchema,
@@ -99,6 +105,10 @@ import {
 	getContentContributionRelationsSchema,
 	getContentContributionsSchema,
 } from './schemas/content/content-contributions.js'
+import {
+	getContentResourceProductRelationsSchema,
+	getContentResourceProductSchema,
+} from './schemas/content/content-resource-product.js'
 import {
 	getContentResourceResourceRelationsSchema,
 	getContentResourceResourceSchema,
@@ -165,6 +175,10 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		upgradableProducts: getUpgradableProductsSchema(mysqlTable),
 		upgradableProductsRelations:
 			getUpgradableProductsRelationsSchema(mysqlTable),
+		contentResourceProduct: getContentResourceProductSchema(mysqlTable),
+		contentResourceProductRelations:
+			getContentResourceProductRelationsSchema(mysqlTable),
+		productRelations: getProductRelationsSchema(mysqlTable),
 	} as const
 }
 
@@ -205,13 +219,20 @@ export function mySqlDrizzleAdapter(
 		availableUpgradesForProduct(
 			purchases: any,
 			productId: string,
-		): Promise<
-			{
-				upgradableTo: { id: string; name: string }
-				upgradableFrom: { id: string; name: string }
-			}[]
-		> {
-			throw new Error('Method not implemented.')
+		): Promise<any[]> {
+			const previousPurchaseProductIds = purchases.map(
+				({ productId }: Purchase) => productId,
+			)
+
+			return client.query.upgradableProducts.findMany({
+				where: and(
+					eq(upgradableProducts.upgradableToId, productId),
+					inArray(
+						upgradableProducts.upgradableFromId,
+						previousPurchaseProductIds,
+					),
+				),
+			})
 		},
 		clearLessonProgressForUser(options: {
 			userId: string
@@ -448,8 +469,16 @@ export function mySqlDrizzleAdapter(
 		}> {
 			throw new Error('Method not implemented.')
 		},
-		getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
-			throw new Error('Method not implemented.')
+		async getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
+			return couponSchema.nullable().parse(
+				await client
+					.select()
+					.from(coupon)
+					.where(
+						or(eq(coupon.id, couponIdOrCode), eq(coupon.code, couponIdOrCode)),
+					)
+					.then((res) => res[0] ?? null),
+			)
 		},
 		getCouponWithBulkPurchases(couponId: string): Promise<
 			| (Coupon & {
@@ -484,21 +513,86 @@ export function mySqlDrizzleAdapter(
 		): Promise<MerchantCharge | null> {
 			throw new Error('Method not implemented.')
 		},
-		getMerchantCoupon(
+		async getMerchantCouponsForTypeAndPercent(params: {
+			type: string
+			percentageDiscount: number
+		}): Promise<MerchantCoupon[]> {
+			return z.array(merchantCouponSchema).parse(
+				await client.query.merchantCoupon.findMany({
+					where: and(
+						eq(merchantCoupon.type, params.type),
+						eq(
+							merchantCoupon.percentageDiscount,
+							params.percentageDiscount.toString(),
+						),
+					),
+				}),
+			)
+		},
+		async getMerchantCouponForTypeAndPercent(params: {
+			type: string
+			percentageDiscount: number
+		}): Promise<MerchantCoupon | null> {
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: and(
+					eq(merchantCoupon.type, params.type),
+					eq(
+						merchantCoupon.percentageDiscount,
+						params.percentageDiscount.toString(),
+					),
+				),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
+		},
+		async getMerchantCoupon(
 			merchantCouponId: string,
 		): Promise<MerchantCoupon | null> {
-			throw new Error('Method not implemented.')
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: eq(merchantCoupon.id, merchantCouponId),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
 		},
-		getMerchantProduct(
+		async getMerchantProduct(
 			stripeProductId: string,
 		): Promise<MerchantProduct | null> {
-			throw new Error('Method not implemented.')
+			return merchantProductSchema.nullable().parse(
+				await client.query.merchantProduct.findFirst({
+					where: eq(merchantProduct.identifier, stripeProductId),
+				}),
+			)
 		},
 		getPrice(productId: string): Promise<Price | null> {
 			throw new Error('Method not implemented.')
 		},
-		getProduct(productId: string): Promise<Product | null> {
-			throw new Error('Method not implemented.')
+		async getPriceForProduct(productId: string): Promise<Price | null> {
+			return priceSchema.nullable().parse(
+				await client.query.prices.findFirst({
+					where: eq(prices.productId, productId),
+				}),
+			)
+		},
+		async getProduct(productId: string): Promise<Product | null> {
+			return productSchema.nullable().parse(
+				await client.query.products.findFirst({
+					where: eq(products.id, productId),
+				}),
+			)
 		},
 		async getPurchase(purchaseId: string): Promise<Purchase | null> {
 			const purchase = await client.query.purchases.findFirst({
@@ -510,7 +604,6 @@ export function mySqlDrizzleAdapter(
 		async createPurchase(options): Promise<Purchase> {
 			const newPurchaseId = options.id || `purchase-${v4()}`
 			await client.insert(purchaseTable).values({
-				state: 'Valid',
 				...options,
 				id: newPurchaseId,
 			})
@@ -524,7 +617,7 @@ export function mySqlDrizzleAdapter(
 			userId: string,
 		): Promise<{
 			purchase?: Purchase
-			existingPurchase?: Purchase
+			existingPurchase?: Purchase & { product?: Product | null }
 			availableUpgrades: UpgradableProduct[]
 		}> {
 			const allPurchases = await this.getPurchasesForUser(userId)
@@ -641,7 +734,7 @@ export function mySqlDrizzleAdapter(
 			const userPurchases = await client.query.purchases.findMany({
 				where: and(
 					eq(purchaseTable.userId, userId),
-					inArray(purchaseTable.state, visiblePurchaseStates),
+					inArray(purchaseTable.status, visiblePurchaseStates),
 				),
 				with: {
 					user: true,
@@ -667,11 +760,50 @@ export function mySqlDrizzleAdapter(
 				}),
 			)
 		},
-		pricesOfPurchasesTowardOneBundle(options: {
+		async pricesOfPurchasesTowardOneBundle({
+			userId,
+			bundleId,
+		}: {
 			userId: string | undefined
 			bundleId: string
 		}): Promise<Price[]> {
-			throw new Error('Method not implemented.')
+			if (userId === undefined) return []
+
+			const canUpgradeProducts = await client.query.upgradableProducts.findMany(
+				{
+					where: eq(upgradableProducts.upgradableToId, bundleId),
+				},
+			)
+
+			const upgradableFrom = z.array(z.string()).parse(
+				canUpgradeProducts.map((product) => {
+					return product.upgradableFromId
+				}),
+			)
+
+			const purchases = await client.query.purchases.findMany({
+				where: and(
+					eq(purchaseTable.userId, userId),
+					inArray(purchaseTable.productId, upgradableFrom),
+				),
+			})
+
+			const purchasesMade = z.array(z.string()).parse(
+				purchases.map((purchase) => {
+					return purchase.productId
+				}),
+			)
+
+			if (purchasesMade.length === 0) return []
+
+			const foundPrices = await client.query.prices.findMany({
+				where: and(
+					eq(prices.productId, bundleId),
+					inArray(prices.productId, purchasesMade),
+				),
+			})
+
+			return z.array(priceSchema).parse(foundPrices)
 		},
 		toggleLessonProgressForUser(options: {
 			userId: string
@@ -788,7 +920,7 @@ export function mySqlDrizzleAdapter(
 		},
 		async getVideoResource(id) {
 			if (!id) {
-				throw new Error('videoResourceId is required')
+				return null
 			}
 
 			const query = sql`
@@ -806,7 +938,7 @@ export function mySqlDrizzleAdapter(
     WHERE
       type = 'videoResource'
       AND (id = ${id});
-      
+
  `
 			return client
 				.execute(query)
@@ -892,7 +1024,6 @@ export function mySqlDrizzleAdapter(
 			return parsedResource.data
 		},
 		async createUser(data) {
-			console.log(data)
 			try {
 				const id = crypto.randomUUID()
 

package/src/lib/mysql/schemas/auth/user-roles.ts

@@ -47,12 +47,12 @@ export function getUserRolesRelationsSchema(mysqlTable: MySqlTableFn) {
 		user: one(users, {
 			fields: [userRoles.userId],
 			references: [users.id],
-			relationName: 'role',
+			relationName: 'user',
 		}),
 		role: one(roles, {
 			fields: [userRoles.roleId],
 			references: [roles.id],
-			relationName: 'user',
+			relationName: 'role',
 		}),
 	}))
 }

package/src/lib/mysql/schemas/commerce/coupon.ts

@@ -1,12 +1,12 @@
 import { sql } from 'drizzle-orm'
 import {
+	boolean,
 	decimal,
 	int,
 	json,
 	MySqlTableFn,
 	primaryKey,
 	timestamp,
-	tinyint,
 	unique,
 	varchar,
 } from 'drizzle-orm/mysql-core'
@@ -23,7 +23,7 @@ export function getCouponSchema(mysqlTable: MySqlTableFn) {
 			expires: timestamp('expires', { mode: 'date', fsp: 3 }),
 			metadata: json('fields').$type<Record<string, any>>().default({}),
 			maxUses: int('maxUses').default(-1).notNull(),
-			default: tinyint('default').default(0).notNull(),
+			default: boolean('default').default(false).notNull(),
 			merchantCouponId: varchar('merchantCouponId', { length: 191 }),
 			status: int('status').default(0).notNull(),
 			usedCount: int('usedCount').default(0).notNull(),

package/src/lib/mysql/schemas/commerce/price.ts

@@ -1,4 +1,4 @@
-import { sql } from 'drizzle-orm'
+import { relations, sql } from 'drizzle-orm'
 import {
 	decimal,
 	int,
@@ -9,6 +9,9 @@ import {
 	varchar,
 } from 'drizzle-orm/mysql-core'
 
+import { getMerchantPriceSchema } from './merchant-price.js'
+import { getProductSchema } from './product.js'
+
 export function getPriceSchema(mysqlTable: MySqlTableFn) {
 	return mysqlTable(
 		'prices',
@@ -30,3 +33,21 @@ export function getPriceSchema(mysqlTable: MySqlTableFn) {
 		},
 	)
 }
+
+export function getProductRelationsSchema(mysqlTable: MySqlTableFn) {
+	const product = getProductSchema(mysqlTable)
+	const price = getPriceSchema(mysqlTable)
+	const merchantPrice = getMerchantPriceSchema(mysqlTable)
+	return relations(price, ({ one, many }) => ({
+		product: one(product, {
+			fields: [price.productId],
+			references: [product.id],
+			relationName: 'user',
+		}),
+		merchantPrice: one(merchantPrice, {
+			fields: [price.id],
+			references: [merchantPrice.priceId],
+			relationName: 'merchantPrice',
+		}),
+	}))
+}

package/src/lib/mysql/schemas/commerce/product.ts

@@ -1,4 +1,4 @@
-import { sql } from 'drizzle-orm'
+import { relations, sql } from 'drizzle-orm'
 import {
 	int,
 	json,
@@ -8,6 +8,10 @@ import {
 	varchar,
 } from 'drizzle-orm/mysql-core'
 
+import { getContentResourceProductSchema } from '../content/content-resource-product.js'
+import { getMerchantProductSchema } from './merchant-product.js'
+import { getPriceSchema } from './price.js'
+
 export function getProductSchema(mysqlTable: MySqlTableFn) {
 	return mysqlTable(
 		'products',
@@ -15,7 +19,7 @@ export function getProductSchema(mysqlTable: MySqlTableFn) {
 			id: varchar('id', { length: 191 }).notNull(),
 			name: varchar('name', { length: 191 }).notNull(),
 			key: varchar('key', { length: 191 }),
-			metadata: json('fields').$type<Record<string, any>>().default({}),
+			fields: json('fields').$type<Record<string, any>>().default({}),
 			createdAt: timestamp('createdAt', { mode: 'date', fsp: 3 })
 				.default(sql`CURRENT_TIMESTAMP(3)`)
 				.notNull(),
@@ -29,3 +33,23 @@ export function getProductSchema(mysqlTable: MySqlTableFn) {
 		},
 	)
 }
+
+export function getProductRelationsSchema(mysqlTable: MySqlTableFn) {
+	const product = getProductSchema(mysqlTable)
+	const price = getPriceSchema(mysqlTable)
+	const merchantProduct = getMerchantProductSchema(mysqlTable)
+	const contentResourceProduct = getContentResourceProductSchema(mysqlTable)
+	return relations(product, ({ one, many }) => ({
+		price: one(price, {
+			fields: [product.id],
+			references: [price.productId],
+			relationName: 'price',
+		}),
+		resources: many(contentResourceProduct, { relationName: 'product' }),
+		merchantProduct: one(merchantProduct, {
+			fields: [product.id],
+			references: [merchantProduct.productId],
+			relationName: 'merchantProduct',
+		}),
+	}))
+}

package/src/lib/mysql/schemas/content/content-resource-product.ts

@@ -0,0 +1,62 @@
+import { relations, sql } from 'drizzle-orm'
+import {
+	double,
+	index,
+	json,
+	MySqlTableFn,
+	primaryKey,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getProductSchema } from '../commerce/product.js'
+import { getContentResourceSchema } from './content-resource.js'
+
+export function getContentResourceProductSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'contentResourceProduct',
+		{
+			productId: varchar('productId', { length: 255 }).notNull(),
+			resourceId: varchar('resourceId', { length: 255 }).notNull(),
+			position: double('position').notNull().default(0),
+			metadata: json('metadata').$type<Record<string, any>>().default({}),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).default(sql`CURRENT_TIMESTAMP(3)`),
+			updatedAt: timestamp('updatedAt', {
+				mode: 'date',
+				fsp: 3,
+			}).default(sql`CURRENT_TIMESTAMP(3)`),
+			deletedAt: timestamp('deletedAt', {
+				mode: 'date',
+				fsp: 3,
+			}),
+		},
+		(crr) => ({
+			pk: primaryKey({ columns: [crr.productId, crr.resourceId] }),
+			contentResourceIdIdx: index('contentResourceId_idx').on(crr.productId),
+			resourceIdIdx: index('resourceId_idx').on(crr.resourceId),
+		}),
+	)
+}
+
+export function getContentResourceProductRelationsSchema(
+	mysqlTable: MySqlTableFn,
+) {
+	const contentResource = getContentResourceSchema(mysqlTable)
+	const contentResourceProduct = getContentResourceProductSchema(mysqlTable)
+	const product = getProductSchema(mysqlTable)
+	return relations(contentResourceProduct, ({ one }) => ({
+		product: one(product, {
+			fields: [contentResourceProduct.productId],
+			references: [product.id],
+			relationName: 'product',
+		}),
+		resource: one(contentResource, {
+			fields: [contentResourceProduct.resourceId],
+			references: [contentResource.id],
+			relationName: 'resource',
+		}),
+	}))
+}

package/src/lib/mysql/schemas/content/content-resource.ts

@@ -9,6 +9,7 @@ import {
 
 import { getUsersSchema } from '../auth/users.js'
 import { getContentContributionsSchema } from './content-contributions.js'
+import { getContentResourceProductSchema } from './content-resource-product.js'
 import { getContentResourceResourceSchema } from './content-resource-resource.js'
 
 export function getContentResourceSchema(mysqlTable: MySqlTableFn) {
@@ -44,6 +45,7 @@ export function getContentResourceRelationsSchema(mysqlTable: MySqlTableFn) {
 	const contentResource = getContentResourceSchema(mysqlTable)
 	const users = getUsersSchema(mysqlTable)
 	const contentResourceResource = getContentResourceResourceSchema(mysqlTable)
+	const contentResourceProduct = getContentResourceProductSchema(mysqlTable)
 	return relations(contentResource, ({ one, many }) => ({
 		createdBy: one(users, {
 			fields: [contentResource.createdById],
@@ -52,5 +54,8 @@ export function getContentResourceRelationsSchema(mysqlTable: MySqlTableFn) {
 		}),
 		resources: many(contentResourceResource, { relationName: 'resourceOf' }),
 		resourceOf: many(contentResourceResource, { relationName: 'resource' }),
+		resourceProducts: many(contentResourceProduct, {
+			relationName: 'resource',
+		}),
 	}))
 }

package/src/lib/utils.ts

@@ -6,8 +6,6 @@ import { type BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core'
 import type { AnySQLiteTable, SQLiteTableFn } from 'drizzle-orm/sqlite-core'
 
 import type { DefaultSchema as MySqlSchema } from './mysql/index.js'
-import type { DefaultSchema as PgSchema } from './pg.js'
-import type { DefaultSchema as SQLiteSchema } from './sqlite.js'
 
 export type AnyMySqlDatabase = MySqlDatabase<any, any>
 export type AnyPgDatabase = PgDatabase<any, any, any>
@@ -15,8 +13,6 @@ 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>
 }
 
 export type SqlFlavorOptions =
@@ -26,11 +22,7 @@ export type SqlFlavorOptions =
 
 export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase
 	? MinimumSchema['mysql']
-	: Flavor extends AnyPgDatabase
-		? MinimumSchema['pg']
-		: Flavor extends AnySQLiteDatabase
-			? MinimumSchema['sqlite']
-			: never
+	: never
 
 export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase
 	? MySqlTableFn