@coursebuilder/adapter-drizzle 0.0.3 → 0.0.4

package/dist/chunk-SBGLYMAH.js

@@ -0,0 +1,45 @@
+import {
+  __name
+} from "./chunk-VNI36MMC.js";
+
+// src/lib/mysql/schemas/commerce/merchant-coupon.ts
+import { decimal, int, primaryKey, unique, varchar } from "drizzle-orm/mysql-core";
+var getMerchantCouponSchema = /* @__PURE__ */ __name((mysqlTable) => {
+  const merchantCoupon = mysqlTable("merchantCoupons", {
+    id: varchar("id", {
+      length: 191
+    }).notNull(),
+    identifier: varchar("identifier", {
+      length: 191
+    }),
+    status: int("status").default(0).notNull(),
+    merchantAccountId: varchar("merchantAccountId", {
+      length: 191
+    }).notNull(),
+    percentageDiscount: decimal("percentageDiscount", {
+      precision: 3,
+      scale: 2
+    }).notNull(),
+    type: varchar("type", {
+      length: 191
+    })
+  }, (table) => {
+    return {
+      merchantCouponId: primaryKey({
+        columns: [
+          table.id
+        ],
+        name: "MerchantCoupon_id"
+      }),
+      merchantCouponIdentifierKey: unique("MerchantCoupon_identifier_key").on(table.identifier)
+    };
+  });
+  return {
+    merchantCoupon
+  };
+}, "getMerchantCouponSchema");
+
+export {
+  getMerchantCouponSchema
+};
+//# sourceMappingURL=chunk-SBGLYMAH.js.map

package/dist/chunk-SQR6UWVO.js

@@ -0,0 +1,225 @@
+import {
+  __name
+} from "./chunk-VNI36MMC.js";
+
+// src/lib/pg.ts
+import { and, eq } from "drizzle-orm";
+import { pgTable as defaultPgTableFn, integer, json, pgEnum, primaryKey, text, timestamp, varchar } from "drizzle-orm/pg-core";
+function createTables(pgTable) {
+  const users = pgTable("user", {
+    id: text("id").notNull().primaryKey(),
+    name: text("name"),
+    email: text("email").notNull(),
+    emailVerified: timestamp("emailVerified", {
+      mode: "date"
+    }),
+    role: pgEnum("role", [
+      "user",
+      "admin"
+    ])("role").default("user"),
+    image: text("image")
+  });
+  const accounts = pgTable("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 = pgTable("session", {
+    sessionToken: text("sessionToken").notNull().primaryKey(),
+    userId: text("userId").notNull().references(() => users.id, {
+      onDelete: "cascade"
+    }),
+    expires: timestamp("expires", {
+      mode: "date"
+    }).notNull()
+  });
+  const verificationTokens = pgTable("verificationToken", {
+    identifier: text("identifier").notNull(),
+    token: text("token").notNull(),
+    expires: timestamp("expires", {
+      mode: "date"
+    }).notNull()
+  }, (vt) => ({
+    pk: primaryKey({
+      columns: [
+        vt.identifier,
+        vt.token
+      ]
+    })
+  }));
+  const contentResource = pgTable("contentResource", {
+    id: varchar("id", {
+      length: 255
+    }).notNull().primaryKey(),
+    type: varchar("type", {
+      length: 255
+    }).notNull(),
+    createdById: varchar("createdById", {
+      length: 255
+    }).notNull(),
+    fields: json("fields").$type().default({}),
+    createdAt: timestamp("createdAt", {
+      mode: "date",
+      precision: 6,
+      withTimezone: true
+    }).defaultNow(),
+    updatedAt: timestamp("updatedAt", {
+      mode: "date",
+      precision: 6,
+      withTimezone: true
+    }).defaultNow(),
+    deletedAt: timestamp("deletedAt", {
+      mode: "date",
+      precision: 6,
+      withTimezone: true
+    })
+  });
+  const contentResourceResource = pgTable("contentResourceResource", {
+    resourceOfId: varchar("resourceOfId", {
+      length: 255
+    }).notNull(),
+    resourceId: varchar("resourceId", {
+      length: 255
+    }).notNull(),
+    position: integer("position").notNull().default(0),
+    metadata: json("fields").$type().default({}),
+    createdAt: timestamp("createdAt", {
+      mode: "date",
+      precision: 6,
+      withTimezone: true
+    }).defaultNow(),
+    updatedAt: timestamp("updatedAt", {
+      mode: "date",
+      precision: 6,
+      withTimezone: true
+    }).defaultNow(),
+    deletedAt: timestamp("deletedAt", {
+      mode: "date",
+      precision: 6,
+      withTimezone: true
+    })
+  }, (crr) => ({
+    pk: primaryKey({
+      columns: [
+        crr.resourceOfId,
+        crr.resourceId
+      ]
+    })
+  }));
+  return {
+    users,
+    accounts,
+    sessions,
+    verificationTokens,
+    contentResource
+  };
+}
+__name(createTables, "createTables");
+function pgDrizzleAdapter(client, tableFn = defaultPgTableFn) {
+  const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn);
+  return {
+    async updateContentResourceFields(options) {
+      return null;
+    },
+    async getVideoResource(id) {
+      return null;
+    },
+    async createContentResource(resource) {
+      return client.insert(contentResource).values({
+        ...resource,
+        id: crypto.randomUUID()
+      }).returning().then((res) => res[0] ?? null);
+    },
+    async getContentResource(data) {
+      const result = await client.select().from(contentResource).where(eq(contentResource.id, data)).then((res) => res[0] ?? null);
+      return result ?? null;
+    },
+    async createUser(data) {
+      return await client.insert(users).values({
+        ...data,
+        id: crypto.randomUUID()
+      }).returning().then((res) => res[0] ?? null);
+    },
+    async getUser(data) {
+      return await client.select().from(users).where(eq(users.id, data)).then((res) => res[0] ?? null);
+    },
+    async getUserByEmail(data) {
+      return await client.select().from(users).where(eq(users.email, data)).then((res) => res[0] ?? null);
+    },
+    async createSession(data) {
+      return await client.insert(sessions).values(data).returning().then((res) => res[0]);
+    },
+    async getSessionAndUser(data) {
+      return await client.select({
+        session: sessions,
+        user: users
+      }).from(sessions).where(eq(sessions.sessionToken, data)).innerJoin(users, eq(users.id, sessions.userId)).then((res) => res[0] ?? null);
+    },
+    async updateUser(data) {
+      if (!data.id) {
+        throw new Error("No user id.");
+      }
+      return await client.update(users).set(data).where(eq(users.id, data.id)).returning().then((res) => res[0]);
+    },
+    async updateSession(data) {
+      return await client.update(sessions).set(data).where(eq(sessions.sessionToken, data.sessionToken)).returning().then((res) => res[0]);
+    },
+    async linkAccount(rawAccount) {
+      await client.insert(accounts).values(rawAccount).returning().then((res) => res[0]);
+    },
+    async getUserByAccount(account) {
+      const dbAccount = await client.select().from(accounts).where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider))).leftJoin(users, eq(accounts.userId, users.id)).then((res) => res[0]) ?? null;
+      return dbAccount?.user ?? null;
+    },
+    async deleteSession(sessionToken) {
+      const session = await client.delete(sessions).where(eq(sessions.sessionToken, sessionToken)).returning().then((res) => res[0] ?? null);
+      return session;
+    },
+    async createVerificationToken(token) {
+      return await client.insert(verificationTokens).values(token).returning().then((res) => res[0]);
+    },
+    async useVerificationToken(token) {
+      try {
+        return await client.delete(verificationTokens).where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token))).returning().then((res) => res[0] ?? null);
+      } catch (err) {
+        throw new Error("No verification token found.");
+      }
+    },
+    async deleteUser(id) {
+      await client.delete(users).where(eq(users.id, id)).returning().then((res) => res[0] ?? null);
+    },
+    async unlinkAccount(account) {
+      const { type, provider, providerAccountId, userId } = await client.delete(accounts).where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider))).returning().then((res) => res[0] ?? null);
+      return {
+        provider,
+        type,
+        providerAccountId,
+        userId
+      };
+    }
+  };
+}
+__name(pgDrizzleAdapter, "pgDrizzleAdapter");
+
+export {
+  createTables,
+  pgDrizzleAdapter
+};
+//# sourceMappingURL=chunk-SQR6UWVO.js.map

package/dist/chunk-SWOTLIQI.js

@@ -0,0 +1,46 @@
+import {
+  __name
+} from "./chunk-VNI36MMC.js";
+
+// src/lib/mysql/schemas/auth/user-permissions.ts
+import { boolean, index, primaryKey, timestamp, varchar } from "drizzle-orm/mysql-core";
+var getUserPermissionsSchema = /* @__PURE__ */ __name((mysqlTable) => {
+  const userPermissions = mysqlTable("userPermission", {
+    userId: varchar("userId", {
+      length: 255
+    }).notNull(),
+    permissionId: varchar("permissionId", {
+      length: 255
+    }).notNull(),
+    active: boolean("active").notNull().default(true),
+    createdAt: timestamp("createdAt", {
+      mode: "date",
+      fsp: 3
+    }).defaultNow(),
+    updatedAt: timestamp("updatedAt", {
+      mode: "date",
+      fsp: 3
+    }).defaultNow(),
+    deletedAt: timestamp("deletedAt", {
+      mode: "date",
+      fsp: 3
+    })
+  }, (up) => ({
+    pk: primaryKey({
+      columns: [
+        up.userId,
+        up.permissionId
+      ]
+    }),
+    userIdIdx: index("userId_idx").on(up.userId),
+    permissionIdIdx: index("permissionId_idx").on(up.permissionId)
+  }));
+  return {
+    userPermissions
+  };
+}, "getUserPermissionsSchema");
+
+export {
+  getUserPermissionsSchema
+};
+//# sourceMappingURL=chunk-SWOTLIQI.js.map