@coursebuilder/adapter-drizzle 0.0.2 → 0.0.4

package/lib/mysql.js

@@ -1,263 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../src/lib/pg.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,UAAU,EAEV,SAAS,EAKV,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAExE,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuG9C;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,YAAY,CAAC,OAAO,UAAU,CAAC,EACvC,OAAO,uBAAmB,GACzB,oBAAoB,CA8ItB"}

package/lib/pg.js

@@ -1,224 +0,0 @@
-import { and, eq } from 'drizzle-orm';
-import { pgTable as defaultPgTableFn, integer, json, pgEnum, primaryKey, text, timestamp, varchar, } from 'drizzle-orm/pg-core';
-export 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 };
-}
-export function pgDrizzleAdapter(client, tableFn = defaultPgTableFn) {
-    const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn);
-    return {
-        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 };
-        },
-    };
-}

package/lib/sqlite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,kBAAkB,EAIlB,aAAa,EAEd,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAIxE,wBAAgB,YAAY,CAAC,WAAW,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FtD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,EAC/C,OAAO,2BAAuB,GAC7B,oBAAoB,CA0GtB"}

package/lib/sqlite.js

@@ -1,182 +0,0 @@
-import { and, eq, sql } from 'drizzle-orm';
-import { sqliteTable as defaultSqliteTableFn, integer, primaryKey, text, } from 'drizzle-orm/sqlite-core';
-import { stripUndefined } from './utils.js';
-export 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 };
-}
-export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
-    const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn);
-    return {
-        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();
-            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();
-        },
-    };
-}