@coursebuilder/adapter-drizzle 0.0.1

package/lib/mysql.js

@@ -0,0 +1,263 @@
+import { addSeconds, isAfter } from 'date-fns';
+import { and, eq, sql } from 'drizzle-orm';
+import { mysqlTable as defaultMySqlTableFn, double, index, int, json, mysqlEnum, primaryKey, timestamp, varchar, } from 'drizzle-orm/mysql-core';
+export function createTables(mySqlTable) {
+    const users = mySqlTable('user', {
+        id: varchar('id', { length: 255 }).notNull().primaryKey(),
+        name: varchar('name', { length: 255 }),
+        email: varchar('email', { length: 255 }).notNull(),
+        role: mysqlEnum('role', ['user', 'admin']).default('user'),
+        emailVerified: timestamp('emailVerified', {
+            mode: 'date',
+            fsp: 3,
+        }).defaultNow(),
+        image: varchar('image', { length: 255 }),
+    });
+    const accounts = mySqlTable('account', {
+        userId: varchar('userId', { length: 255 })
+            .notNull()
+            .references(() => users.id, { onDelete: 'cascade' }),
+        type: varchar('type', { length: 255 }).$type().notNull(),
+        provider: varchar('provider', { length: 255 }).notNull(),
+        providerAccountId: varchar('providerAccountId', {
+            length: 255,
+        }).notNull(),
+        refresh_token: varchar('refresh_token', { length: 255 }),
+        access_token: varchar('access_token', { length: 255 }),
+        expires_at: int('expires_at'),
+        token_type: varchar('token_type', { length: 255 }),
+        scope: varchar('scope', { length: 255 }),
+        id_token: varchar('id_token', { length: 255 }),
+        session_state: varchar('session_state', { length: 255 }),
+    }, (account) => ({
+        pk: primaryKey({ columns: [account.provider, account.providerAccountId] }),
+        userIdIdx: index('userId_idx').on(account.userId),
+    }));
+    const sessions = mySqlTable('session', {
+        sessionToken: varchar('sessionToken', { length: 255 }).notNull().primaryKey(),
+        userId: varchar('userId', { length: 255 })
+            .notNull()
+            .references(() => users.id, { onDelete: 'cascade' }),
+        expires: timestamp('expires', { mode: 'date' }).notNull(),
+    }, (session) => ({
+        userIdIdx: index('userId_idx').on(session.userId),
+    }));
+    const verificationTokens = mySqlTable('verificationToken', {
+        identifier: varchar('identifier', { length: 255 }).notNull(),
+        token: varchar('token', { length: 255 }).notNull(),
+        expires: timestamp('expires', { mode: 'date' }).notNull(),
+        createdAt: timestamp('createdAt', {
+            mode: 'date',
+            fsp: 3,
+        }).default(sql `CURRENT_TIMESTAMP(3)`),
+    }, (vt) => ({
+        pk: primaryKey({ columns: [vt.identifier, vt.token] }),
+    }));
+    const contentResource = mySqlTable('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',
+            fsp: 3,
+        }).defaultNow(),
+        updatedAt: timestamp('updatedAt', {
+            mode: 'date',
+            fsp: 3,
+        }).defaultNow(),
+        deletedAt: timestamp('deletedAt', {
+            mode: 'date',
+            fsp: 3,
+        }),
+    }, (cm) => ({
+        typeIdx: index('type_idx').on(cm.type),
+        createdByIdx: index('createdById_idx').on(cm.createdById),
+        createdAtIdx: index('createdAt_idx').on(cm.createdAt),
+    }));
+    const contentResourceResource = mySqlTable('contentResourceResource', {
+        resourceOfId: varchar('resourceOfId', { length: 255 }).notNull(),
+        resourceId: varchar('resourceId', { length: 255 }).notNull(),
+        position: double('position').notNull().default(0),
+        metadata: json('fields').$type().default({}),
+        createdAt: timestamp('createdAt', {
+            mode: 'date',
+            fsp: 3,
+        }).defaultNow(),
+        updatedAt: timestamp('updatedAt', {
+            mode: 'date',
+            fsp: 3,
+        }).defaultNow(),
+        deletedAt: timestamp('deletedAt', {
+            mode: 'date',
+            fsp: 3,
+        }),
+    }, (crr) => ({
+        pk: primaryKey({ columns: [crr.resourceOfId, crr.resourceId] }),
+        contentResourceIdIdx: index('contentResourceId_idx').on(crr.resourceOfId),
+        resourceIdIdx: index('resourceId_idx').on(crr.resourceId),
+    }));
+    return { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource };
+}
+export function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
+    const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn);
+    return {
+        async createContentResource(data) {
+            const id = crypto.randomUUID();
+            await client.insert(contentResource).values({ ...data, id });
+            return await client
+                .select()
+                .from(contentResource)
+                .where(eq(contentResource.id, id))
+                .then((res) => res[0]);
+        },
+        async getContentResource(data) {
+            const thing = (await client
+                .select()
+                .from(contentResource)
+                .where(eq(contentResource.id, data))
+                .then((res) => res[0])) ?? null;
+            return thing;
+        },
+        async createUser(data) {
+            const id = crypto.randomUUID();
+            await client.insert(users).values({ ...data, id });
+            return await client
+                .select()
+                .from(users)
+                .where(eq(users.id, id))
+                .then((res) => res[0]);
+        },
+        async getUser(data) {
+            const thing = (await client
+                .select()
+                .from(users)
+                .where(eq(users.id, data))
+                .then((res) => res[0])) ?? null;
+            return thing;
+        },
+        async getUserByEmail(data) {
+            const user = (await client
+                .select()
+                .from(users)
+                .where(eq(users.email, data))
+                .then((res) => res[0])) ?? null;
+            return user;
+        },
+        async createSession(data) {
+            await client.insert(sessions).values(data);
+            return await client
+                .select()
+                .from(sessions)
+                .where(eq(sessions.sessionToken, data.sessionToken))
+                .then((res) => res[0]);
+        },
+        async getSessionAndUser(data) {
+            const sessionAndUser = (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;
+            return sessionAndUser;
+        },
+        async updateUser(data) {
+            if (!data.id) {
+                throw new Error('No user id.');
+            }
+            await client.update(users).set(data).where(eq(users.id, data.id));
+            return await client
+                .select()
+                .from(users)
+                .where(eq(users.id, data.id))
+                .then((res) => res[0]);
+        },
+        async updateSession(data) {
+            await client.update(sessions).set(data).where(eq(sessions.sessionToken, data.sessionToken));
+            return await client
+                .select()
+                .from(sessions)
+                .where(eq(sessions.sessionToken, data.sessionToken))
+                .then((res) => res[0]);
+        },
+        async linkAccount(rawAccount) {
+            await client.insert(accounts).values(rawAccount);
+        },
+        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;
+            if (!dbAccount) {
+                return null;
+            }
+            return dbAccount.user;
+        },
+        async deleteSession(sessionToken) {
+            const session = (await client
+                .select()
+                .from(sessions)
+                .where(eq(sessions.sessionToken, sessionToken))
+                .then((res) => res[0])) ?? null;
+            await client.delete(sessions).where(eq(sessions.sessionToken, sessionToken));
+            return session;
+        },
+        async createVerificationToken(token) {
+            await client.insert(verificationTokens).values(token);
+            return await client
+                .select()
+                .from(verificationTokens)
+                .where(eq(verificationTokens.identifier, token.identifier))
+                .then((res) => res[0]);
+        },
+        async useVerificationToken(token) {
+            try {
+                const deletedToken = (await client
+                    .select()
+                    .from(verificationTokens)
+                    .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
+                    .then((res) => res[0])) ?? null;
+                if (deletedToken?.createdAt) {
+                    const TIMEOUT_IN_SECONDS = 90;
+                    const expireMultipleClicks = addSeconds(deletedToken.createdAt, TIMEOUT_IN_SECONDS);
+                    const now = new Date();
+                    if (isAfter(expireMultipleClicks, now)) {
+                        // @ts-ignore
+                        const { id: _, ...verificationToken } = token;
+                        return deletedToken;
+                    }
+                    else {
+                        await client
+                            .delete(verificationTokens)
+                            .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)));
+                        return deletedToken;
+                    }
+                }
+                return deletedToken;
+            }
+            catch (err) {
+                throw new Error('No verification token found.');
+            }
+        },
+        async deleteUser(id) {
+            const user = await client
+                .select()
+                .from(users)
+                .where(eq(users.id, id))
+                .then((res) => res[0] ?? null);
+            await client.delete(users).where(eq(users.id, id));
+            return user;
+        },
+        async unlinkAccount(account) {
+            await client
+                .delete(accounts)
+                .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)));
+            return undefined;
+        },
+    };
+}

package/lib/pg.d.ts

@@ -0,0 +1,299 @@
+import type { Adapter } from '@auth/core/adapters';
+import { PgDatabase, PgTableFn } from 'drizzle-orm/pg-core';
+export declare function createTables(pgTable: PgTableFn): {
+    users: import("drizzle-orm/pg-core/table.js").PgTableWithColumns<{
+        name: "user";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "id";
+                tableName: "user";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            name: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "name";
+                tableName: "user";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            email: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "email";
+                tableName: "user";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            emailVerified: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "emailVerified";
+                tableName: "user";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+            }, {}, {}>;
+            image: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "image";
+                tableName: "user";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+    accounts: import("drizzle-orm/pg-core/table.js").PgTableWithColumns<{
+        name: "account";
+        schema: undefined;
+        columns: {
+            userId: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "userId";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            type: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "type";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: "email" | "oidc" | "oauth" | "webauthn";
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            provider: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "provider";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            providerAccountId: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "providerAccountId";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            refresh_token: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "refresh_token";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            access_token: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "access_token";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            expires_at: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "expires_at";
+                tableName: "account";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+            }, {}, {}>;
+            token_type: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "token_type";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            scope: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "scope";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            id_token: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "id_token";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            session_state: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "session_state";
+                tableName: "account";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+    sessions: import("drizzle-orm/pg-core/table.js").PgTableWithColumns<{
+        name: "session";
+        schema: undefined;
+        columns: {
+            sessionToken: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "sessionToken";
+                tableName: "session";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            userId: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "userId";
+                tableName: "session";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            expires: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "expires";
+                tableName: "session";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+    verificationTokens: import("drizzle-orm/pg-core/table.js").PgTableWithColumns<{
+        name: "verificationToken";
+        schema: undefined;
+        columns: {
+            identifier: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "identifier";
+                tableName: "verificationToken";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            token: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "token";
+                tableName: "verificationToken";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, {}, {}>;
+            expires: import("drizzle-orm/pg-core/index.js").PgColumn<{
+                name: "expires";
+                tableName: "verificationToken";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+};
+export type DefaultSchema = ReturnType<typeof createTables>;
+export declare function pgDrizzleAdapter(client: InstanceType<typeof PgDatabase>, tableFn?: PgTableFn<undefined>): Adapter;
+//# sourceMappingURL=pg.d.ts.map

package/lib/pg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../src/lib/pg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAA+C,MAAM,qBAAqB,CAAA;AAE/F,OAAO,EAGL,UAAU,EACV,SAAS,EAIV,MAAM,qBAAqB,CAAA;AAI5B,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD9C;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,UAAU,CAAC,EAAE,OAAO,uBAAmB,GAAG,OAAO,CA+H7G"}