Socket
Socket
Sign inDemoInstall

@next-auth/prisma-adapter

Package Overview
Dependencies
Maintainers
4
Versions
110
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@next-auth/prisma-adapter - npm Package Compare versions

Comparing version 0.4.4-pr.75.39 to 0.4.4-pr.76.41

5

dist/index.d.ts
import type * as Prisma from "@prisma/client";
import type { Profile } from "next-auth";
import type { Adapter } from "next-auth/adapters";
declare const PrismaAdapter: Adapter<{
prisma: Prisma.PrismaClient;
}, never, Prisma.User, Profile & {
export declare const PrismaAdapter: Adapter<Prisma.PrismaClient, never, Prisma.User, Profile & {
emailVerified?: Date;
}, Prisma.Session>;
export default PrismaAdapter;

476

dist/index.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
Object.defineProperty(exports, "__esModule", { value: true });
var crypto_1 = require("crypto");
function verificationRequestToken(_a) {
var token = _a.token, secret = _a.secret;
// TODO: Use bcrypt or a more secure method
return crypto_1.createHash("sha256").update("" + token + secret).digest("hex");
}
var PrismaAdapter = function (_a) {
var prisma = _a.prisma;
exports.PrismaAdapter = void 0;
const crypto_1 = require("crypto");
const PrismaAdapter = (prisma) => {
return {
getAdapter: function (_a) {
var logger = _a.logger, session = _a.session, appOptions = __rest(_a, ["logger", "session"]);
return __awaiter(this, void 0, void 0, function () {
function debug(debugCode) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
async getAdapter({ session, secret, ...appOptions }) {
const sessionMaxAgeMs = session.maxAge * 1000; // default is 30 days
const sessionUpdateAgeMs = session.updateAge * 1000; // default is 1 day
/**
* @todo Move this to core package
* @todo Use bcrypt or a more secure method
*/
const hashToken = (token) => crypto_1.createHash("sha256").update(`${token}${secret}`).digest("hex");
return {
createUser(profile) {
var _a, _b;
return prisma.user.create({
data: {
name: profile.name,
email: profile.email,
image: profile.image,
emailVerified: (_b = (_a = profile.emailVerified) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : null,
},
});
},
getUser(id) {
return prisma.user.findUnique({
where: { id },
});
},
getUserByEmail(email) {
if (!email)
return Promise.resolve(null);
return prisma.user.findUnique({ where: { email } });
},
async getUserByProviderAccountId(providerId, providerAccountId) {
var _a;
const account = await prisma.account.findUnique({
where: {
providerId_providerAccountId: { providerId, providerAccountId },
},
select: { user: true },
});
return (_a = account === null || account === void 0 ? void 0 : account.user) !== null && _a !== void 0 ? _a : null;
},
updateUser(user) {
var _a, _b;
return prisma.user.update({
where: { id: user.id },
data: {
name: user.name,
email: user.email,
image: user.image,
emailVerified: (_b = (_a = user.emailVerified) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : null,
},
});
},
async deleteUser(userId) {
await prisma.user.delete({
where: { id: userId },
});
},
async linkAccount(userId, providerId, providerType, providerAccountId, refreshToken, accessToken, accessTokenExpires) {
await prisma.account.create({
data: {
userId,
providerId,
providerType,
providerAccountId,
refreshToken,
accessToken,
accessTokenExpires: accessTokenExpires != null
? new Date(accessTokenExpires)
: null,
},
});
},
async unlinkAccount(_, providerId, providerAccountId) {
await prisma.account.delete({
where: {
providerId_providerAccountId: { providerId, providerAccountId },
},
});
},
createSession(user) {
return prisma.session.create({
data: {
userId: user.id,
expires: new Date(Date.now() + sessionMaxAgeMs),
sessionToken: crypto_1.randomBytes(32).toString("hex"),
accessToken: crypto_1.randomBytes(32).toString("hex"),
},
});
},
async getSession(sessionToken) {
const session = await prisma.session.findUnique({
where: { sessionToken },
});
if (session && session.expires < new Date()) {
await prisma.session.delete({ where: { sessionToken } });
return null;
}
logger.debug.apply(logger, __spreadArray(["PRISMA_" + debugCode], args));
}
var _b, maxAge, _c, updateAge, sessionMaxAgeMs, sessionUpdateAgeMs;
return __generator(this, function (_d) {
if (!session.maxAge) {
debug("GET_ADAPTER", "Session expiry not configured (defaulting to 30 days)");
return session;
},
async updateSession(session, force) {
if (!force &&
Number(session.expires) - sessionMaxAgeMs + sessionUpdateAgeMs >
Date.now()) {
return null;
}
if (!session.updateAge) {
debug("GET_ADAPTER", "Session update age not configured (defaulting to 1 day)");
return await prisma.session.update({
where: { id: session.id },
data: {
expires: new Date(Date.now() + sessionMaxAgeMs),
},
});
},
async deleteSession(sessionToken) {
await prisma.session.delete({ where: { sessionToken } });
},
async createVerificationRequest(identifier, url, token, _, provider) {
await prisma.verificationRequest.create({
data: {
identifier,
token: hashToken(token),
expires: new Date(Date.now() + provider.maxAge * 1000),
},
});
await provider.sendVerificationRequest({
identifier,
url,
token,
baseUrl: appOptions.baseUrl,
provider,
});
},
async getVerificationRequest(identifier, token) {
const hashedToken = hashToken(token);
const verificationRequest = await prisma.verificationRequest.findUnique({
where: { identifier_token: { identifier, token: hashedToken } },
});
if (verificationRequest && verificationRequest.expires < new Date()) {
await prisma.verificationRequest.delete({
where: { identifier_token: { identifier, token: hashedToken } },
});
return null;
}
_b = session.maxAge, maxAge = _b === void 0 ? 30 * 24 * 60 * 60 : _b, _c = session.updateAge, updateAge = _c === void 0 ? 24 * 60 * 60 : _c;
sessionMaxAgeMs = maxAge * 1000;
sessionUpdateAgeMs = updateAge * 1000;
return [2 /*return*/, {
createUser: function (profile) {
var _a, _b;
return prisma.user.create({
data: {
name: profile.name,
email: profile.email,
image: profile.image,
emailVerified: (_b = (_a = profile.emailVerified) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : null,
},
});
},
getUser: function (id) {
return prisma.user.findUnique({
where: { id: id },
});
},
getUserByEmail: function (email) {
if (!email)
return Promise.resolve(null);
return prisma.user.findUnique({ where: { email: email } });
},
getUserByProviderAccountId: function (providerId, providerAccountId) {
var _a;
return __awaiter(this, void 0, void 0, function () {
var account;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, prisma.account.findUnique({
where: {
providerId_providerAccountId: { providerId: providerId, providerAccountId: providerAccountId },
},
select: { user: true },
})];
case 1:
account = _b.sent();
return [2 /*return*/, (_a = account === null || account === void 0 ? void 0 : account.user) !== null && _a !== void 0 ? _a : null];
}
});
});
},
updateUser: function (user) {
var _a, _b;
return prisma.user.update({
where: { id: user.id },
data: {
name: user.name,
email: user.email,
image: user.image,
emailVerified: (_b = (_a = user.emailVerified) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : null,
},
});
},
deleteUser: function (userId) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, prisma.user.delete({
where: { id: userId },
})];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
},
linkAccount: function (userId, providerId, providerType, providerAccountId, refreshToken, accessToken, accessTokenExpires) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, prisma.account.create({
data: {
userId: userId,
providerId: providerId,
providerType: providerType,
providerAccountId: providerAccountId,
refreshToken: refreshToken,
accessToken: accessToken,
accessTokenExpires: accessTokenExpires != null
? new Date(accessTokenExpires)
: null,
},
})];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
},
unlinkAccount: function (_, providerId, providerAccountId) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, prisma.account.delete({
where: {
providerId_providerAccountId: { providerId: providerId, providerAccountId: providerAccountId },
},
})];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
},
createSession: function (user) {
return prisma.session.create({
data: {
userId: user.id,
expires: new Date(Date.now() + sessionMaxAgeMs),
sessionToken: crypto_1.randomBytes(32).toString("hex"),
accessToken: crypto_1.randomBytes(32).toString("hex"),
},
});
},
getSession: function (sessionToken) {
return __awaiter(this, void 0, void 0, function () {
var session;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, prisma.session.findUnique({
where: { sessionToken: sessionToken },
})];
case 1:
session = _a.sent();
if (!(session && session.expires < new Date())) return [3 /*break*/, 3];
return [4 /*yield*/, prisma.session.delete({ where: { sessionToken: sessionToken } })];
case 2:
_a.sent();
return [2 /*return*/, null];
case 3: return [2 /*return*/, session];
}
});
});
},
updateSession: function (session, force) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!force &&
Number(session.expires) - sessionMaxAgeMs + sessionUpdateAgeMs >
Date.now()) {
return [2 /*return*/, null];
}
return [4 /*yield*/, prisma.session.update({
where: { id: session.id },
data: {
expires: new Date(Date.now() + sessionMaxAgeMs),
},
})];
case 1: return [2 /*return*/, _a.sent()];
}
});
});
},
deleteSession: function (sessionToken) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, prisma.session.delete({ where: { sessionToken: sessionToken } })];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
},
createVerificationRequest: function (identifier, url, token, secret, provider) {
return __awaiter(this, void 0, void 0, function () {
var hashedToken;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
hashedToken = verificationRequestToken({ token: token, secret: secret });
return [4 /*yield*/, prisma.verificationRequest.create({
data: {
identifier: identifier,
token: hashedToken,
expires: new Date(Date.now() + provider.maxAge * 1000),
},
})];
case 1:
_a.sent();
return [4 /*yield*/, provider.sendVerificationRequest({
identifier: identifier,
url: url,
token: token,
baseUrl: appOptions.baseUrl,
provider: provider,
})];
case 2:
_a.sent();
return [2 /*return*/];
}
});
});
},
getVerificationRequest: function (identifier, token, secret) {
return __awaiter(this, void 0, void 0, function () {
var hashedToken, verificationRequest;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
hashedToken = verificationRequestToken({ token: token, secret: secret });
return [4 /*yield*/, prisma.verificationRequest.findUnique({
where: { identifier_token: { identifier: identifier, token: hashedToken } },
})];
case 1:
verificationRequest = _a.sent();
if (!(verificationRequest && verificationRequest.expires < new Date())) return [3 /*break*/, 3];
return [4 /*yield*/, prisma.verificationRequest.delete({
where: { identifier_token: { identifier: identifier, token: hashedToken } },
})];
case 2:
_a.sent();
return [2 /*return*/, null];
case 3: return [2 /*return*/, verificationRequest];
}
});
});
},
deleteVerificationRequest: function (identifier, token, secret) {
return __awaiter(this, void 0, void 0, function () {
var hashedToken;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
hashedToken = verificationRequestToken({ token: token, secret: secret });
return [4 /*yield*/, prisma.verificationRequest.delete({
where: { identifier_token: { identifier: identifier, token: hashedToken } },
})];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
},
}];
});
});
return verificationRequest;
},
async deleteVerificationRequest(identifier, token) {
await prisma.verificationRequest.delete({
where: {
identifier_token: { identifier, token: hashToken(token) },
},
});
},
};
},
};
};
exports.default = PrismaAdapter;
exports.PrismaAdapter = PrismaAdapter;

4

package.json
{
"name": "@next-auth/prisma-adapter",
"version": "0.4.4-pr.75.39+5c99cab",
"version": "0.4.4-pr.76.41+c6bf056",
"description": "Prisma adapter for next-auth.",

@@ -45,3 +45,3 @@ "homepage": "https://next-auth.js.org",

},
"gitHead": "5c99cabad12ca256833e8399698f2d1e3c90ee2c"
"gitHead": "c6bf0565d7805c5d17ebe731549c4c13aee48377"
}
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc