@coursebuilder/adapter-drizzle 0.1.1 → 0.1.3

package/dist/chunk-O2KKII62.js

@@ -1,381 +0,0 @@
-import {
-  stripUndefined
-} from "./chunk-GFUUJRX7.js";
-import {
-  ContentResourceSchema
-} from "./chunk-Y34AIPU7.js";
-import {
-  __name
-} from "./chunk-VNI36MMC.js";
-
-// src/lib/sqlite.ts
-import { and, asc, eq, sql } from "drizzle-orm";
-import { sqliteTable as defaultSqliteTableFn, integer, primaryKey, text } from "drizzle-orm/sqlite-core";
-function createTables(sqliteTable) {
-  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().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 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().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().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
-  };
-}
-__name(createTables, "createTables");
-function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
-  const { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource } = createTables(tableFn);
-  return {
-    client,
-    availableUpgradesForProduct(purchases, productId) {
-      return Promise.resolve([]);
-    },
-    clearLessonProgressForUser(options) {
-      return Promise.resolve(void 0);
-    },
-    completeLessonProgressForUser(options) {
-      return Promise.resolve(null);
-    },
-    couponForIdOrCode(options) {
-      return Promise.resolve(null);
-    },
-    createMerchantChargeAndPurchase(options) {
-      throw new Error("Method not implemented.");
-    },
-    findOrCreateMerchantCustomer(options) {
-      return Promise.resolve(null);
-    },
-    findOrCreateUser(email, name) {
-      throw new Error("Method not implemented.");
-    },
-    getCoupon(couponIdOrCode) {
-      return Promise.resolve(null);
-    },
-    getCouponWithBulkPurchases(couponId) {
-      return Promise.resolve(null);
-    },
-    getDefaultCoupon(productIds) {
-      return Promise.resolve(null);
-    },
-    getLessonProgressCountsByDate() {
-      return Promise.resolve([]);
-    },
-    getLessonProgressForUser(userId) {
-      return Promise.resolve([]);
-    },
-    getLessonProgresses() {
-      return Promise.resolve([]);
-    },
-    getMerchantCharge(merchantChargeId) {
-      return Promise.resolve(null);
-    },
-    getMerchantCoupon(merchantCouponId) {
-      return Promise.resolve(null);
-    },
-    getMerchantProduct(stripeProductId) {
-      return Promise.resolve(null);
-    },
-    getPrice(productId) {
-      return Promise.resolve(null);
-    },
-    getProduct(productId) {
-      return Promise.resolve(null);
-    },
-    getPurchase(purchaseId) {
-      return Promise.resolve(null);
-    },
-    getPurchaseDetails(purchaseId, userId) {
-      return Promise.resolve({
-        availableUpgrades: []
-      });
-    },
-    getPurchaseForStripeCharge(stripeChargeId) {
-      return Promise.resolve(null);
-    },
-    getPurchaseUserTransferById(options) {
-      return Promise.resolve(null);
-    },
-    getPurchaseWithUser(purchaseId) {
-      return Promise.resolve(null);
-    },
-    getPurchasesForUser(userId) {
-      return Promise.resolve([]);
-    },
-    getUserById(userId) {
-      return Promise.resolve(null);
-    },
-    pricesOfPurchasesTowardOneBundle(options) {
-      return Promise.resolve([]);
-    },
-    async createPurchase(options) {
-      throw new Error("Method not implemented.");
-    },
-    toggleLessonProgressForUser(options) {
-      return Promise.resolve(null);
-    },
-    transferPurchasesToNewUser(options) {
-      return Promise.resolve(void 0);
-    },
-    updatePurchaseStatusForCharge(chargeId, status) {
-      return Promise.resolve(void 0);
-    },
-    updatePurchaseUserTransferTransferState(options) {
-      return Promise.resolve(null);
-    },
-    async addResourceToResource(options) {
-      return null;
-    },
-    async updateContentResourceFields(options) {
-      return null;
-    },
-    async getVideoResource(id) {
-      return null;
-    },
-    async createContentResource(data) {
-      const id = data.id || crypto.randomUUID();
-      await client.insert(contentResource).values({
-        ...data,
-        id
-      });
-      const resource = await client.query.contentResource.findFirst({
-        where: eq(contentResource.id, id),
-        with: {
-          resources: {
-            with: {
-              resource: {
-                with: {
-                  resources: {
-                    with: {
-                      resource: true
-                    },
-                    orderBy: asc(contentResourceResource.position)
-                  }
-                }
-              }
-            },
-            orderBy: asc(contentResourceResource.position)
-          }
-        }
-      });
-      const parsedResource = ContentResourceSchema.safeParse(resource);
-      if (!parsedResource.success) {
-        console.error("Error parsing resource", resource);
-        throw new Error("Error parsing resource");
-      }
-      return parsedResource.data;
-    },
-    async getContentResource(data) {
-      const resource = await client.query.contentResource.findFirst({
-        where: eq(contentResource.id, data),
-        with: {
-          resources: {
-            with: {
-              resource: {
-                with: {
-                  resources: {
-                    with: {
-                      resource: true
-                    },
-                    orderBy: asc(contentResourceResource.position)
-                  }
-                }
-              }
-            },
-            orderBy: asc(contentResourceResource.position)
-          }
-        }
-      });
-      const parsedResource = ContentResourceSchema.safeParse(resource);
-      if (!parsedResource.success) {
-        console.error("Error parsing resource", resource);
-        return null;
-      }
-      return parsedResource.data;
-    },
-    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();
-      if (!results) {
-        return null;
-      }
-      return Promise.resolve(results).then((results2) => results2.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();
-    }
-  };
-}
-__name(SQLiteDrizzleAdapter, "SQLiteDrizzleAdapter");
-
-export {
-  createTables,
-  SQLiteDrizzleAdapter
-};
-//# sourceMappingURL=chunk-O2KKII62.js.map