@gatwech/auth 1.0.0-beta.18

package/dist/crypto-Bb42eMrH.mjs

@@ -0,0 +1,70 @@
+import { PayvoAuthError } from "@gatwech/core/error";
+import { createHash } from "@gatwech/utils/hash";
+import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { bytesToHex, hexToBytes, managedNonce, utf8ToBytes } from "@noble/ciphers/utils.js";
+import { hex } from "@gatwech/utils/hex";
+import { scryptAsync } from "@noble/hashes/scrypt.js";
+import { hexToBytes as hexToBytes$1 } from "@noble/hashes/utils.js";
+import { createRandomStringGenerator } from "@gatwech/utils/random";
+
+//#region src/crypto/buffer.ts
+/**
+* Compare two buffers in constant time.
+*/
+function constantTimeEqual(a, b) {
+	const aBuffer = new Uint8Array(a);
+	const bBuffer = new Uint8Array(b);
+	let c = aBuffer.length ^ bBuffer.length;
+	const length = Math.max(aBuffer.length, bBuffer.length);
+	for (let i = 0; i < length; i++) c |= (i < aBuffer.length ? aBuffer[i] : 0) ^ (i < bBuffer.length ? bBuffer[i] : 0);
+	return c === 0;
+}
+
+//#endregion
+//#region src/crypto/password.ts
+const config = {
+	N: 16384,
+	r: 16,
+	p: 1,
+	dkLen: 64
+};
+async function generateKey(password, salt) {
+	return await scryptAsync(password.normalize("NFKC"), salt, {
+		N: config.N,
+		p: config.p,
+		r: config.r,
+		dkLen: config.dkLen,
+		maxmem: 128 * config.N * config.r * 2
+	});
+}
+const hashPassword = async (password) => {
+	const salt = hex.encode(crypto.getRandomValues(new Uint8Array(16)));
+	const key = await generateKey(password, salt);
+	return `${salt}:${hex.encode(key)}`;
+};
+const verifyPassword = async ({ hash, password }) => {
+	const [salt, key] = hash.split(":");
+	if (!salt || !key) throw new PayvoAuthError("Invalid password hash");
+	return constantTimeEqual(await generateKey(password, salt), hexToBytes$1(key));
+};
+
+//#endregion
+//#region src/crypto/random.ts
+const generateRandomString = createRandomStringGenerator("a-z", "0-9", "A-Z", "-_");
+
+//#endregion
+//#region src/crypto/index.ts
+const symmetricEncrypt = async ({ key, data }) => {
+	const keyAsBytes = await createHash("SHA-256", "none").digest(key);
+	const dataAsBytes = utf8ToBytes(data);
+	return bytesToHex(managedNonce(xchacha20poly1305)(new Uint8Array(keyAsBytes)).encrypt(dataAsBytes));
+};
+const symmetricDecrypt = async ({ key, data }) => {
+	const keyAsBytes = await createHash("SHA-256", "none").digest(key);
+	const dataAsBytes = hexToBytes(data);
+	const chacha = managedNonce(xchacha20poly1305)(new Uint8Array(keyAsBytes));
+	return new TextDecoder().decode(chacha.decrypt(dataAsBytes));
+};
+
+//#endregion
+export { verifyPassword as a, hashPassword as i, symmetricEncrypt as n, constantTimeEqual as o, generateRandomString as r, symmetricDecrypt as t };

package/dist/custom-session-L3t7ecsd.mjs

@@ -0,0 +1,67 @@
+import { n as getSession } from "./session-Dgp133Yt.mjs";
+import { t as getEndpointResponse } from "./plugin-helper-4L-lzsjZ.mjs";
+import { createAuthEndpoint, createAuthMiddleware } from "@gatwech/core/api";
+import * as z$1 from "zod";
+
+//#region src/plugins/custom-session/index.ts
+const getSessionQuerySchema = z$1.optional(z$1.object({
+	disableCookieCache: z$1.boolean().meta({ description: "Disable cookie cache and fetch session from database" }).or(z$1.string().transform((v) => v === "true")).optional(),
+	disableRefresh: z$1.boolean().meta({ description: "Disable session refresh. Useful for checking session status, without updating the session" }).optional()
+}));
+const customSession = (fn, options, pluginOptions) => {
+	return {
+		id: "custom-session",
+		hooks: { after: [{
+			matcher: (ctx) => ctx.path === "/multi-session/list-device-sessions" && (pluginOptions?.shouldMutateListDeviceSessionsEndpoint ?? false),
+			handler: createAuthMiddleware(async (ctx) => {
+				const response = await getEndpointResponse(ctx);
+				if (!response) return;
+				const newResponse = await Promise.all(response.map(async (v) => await fn(v, ctx)));
+				return ctx.json(newResponse);
+			})
+		}] },
+		endpoints: { getSession: createAuthEndpoint("/get-session", {
+			method: "GET",
+			query: getSessionQuerySchema,
+			metadata: {
+				CUSTOM_SESSION: true,
+				openapi: {
+					description: "Get custom session data",
+					responses: { "200": {
+						description: "Success",
+						content: { "application/json": { schema: {
+							type: "array",
+							nullable: true,
+							items: { $ref: "#/components/schemas/Session" }
+						} } }
+					} }
+				}
+			},
+			requireHeaders: true
+		}, async (ctx) => {
+			const session = await getSession()({
+				...ctx,
+				asResponse: false,
+				headers: ctx.headers,
+				returnHeaders: true
+			}).catch((e) => {
+				return null;
+			});
+			if (!session?.response) return ctx.json(null);
+			const fnResult = await fn(session.response, ctx);
+			const setCookie = session.headers.get("set-cookie");
+			if (setCookie) {
+				ctx.setHeader("set-cookie", setCookie);
+				session.headers.delete("set-cookie");
+			}
+			session.headers.forEach((value, key) => {
+				ctx.setHeader(key, value);
+			});
+			return ctx.json(fnResult);
+		}) },
+		$Infer: { Session: {} }
+	};
+};
+
+//#endregion
+export { customSession as t };

package/dist/date-Cx2yCiC4.mjs

@@ -0,0 +1,115 @@
+import { APIError } from "better-call";
+
+//#region src/db/schema.ts
+const cache = /* @__PURE__ */ new WeakMap();
+function parseOutputData(data, schema) {
+	const fields = schema.fields;
+	const parsedData = {};
+	for (const key in data) {
+		const field = fields[key];
+		if (!field) {
+			parsedData[key] = data[key];
+			continue;
+		}
+		if (field.returned === false) continue;
+		parsedData[key] = data[key];
+	}
+	return parsedData;
+}
+function getAllFields(options, table) {
+	if (!cache.has(options)) cache.set(options, /* @__PURE__ */ new Map());
+	const tableCache = cache.get(options);
+	if (tableCache.has(table)) return tableCache.get(table);
+	let schema = {
+		...table === "user" ? options.user?.additionalFields : {},
+		...table === "session" ? options.session?.additionalFields : {}
+	};
+	for (const plugin of options.plugins || []) if (plugin.schema && plugin.schema[table]) schema = {
+		...schema,
+		...plugin.schema[table].fields
+	};
+	cache.get(options).set(table, schema);
+	return schema;
+}
+function parseUserOutput(options, user) {
+	return parseOutputData(user, { fields: getAllFields(options, "user") });
+}
+function parseAccountOutput(options, account) {
+	return parseOutputData(account, { fields: getAllFields(options, "account") });
+}
+function parseSessionOutput(options, session) {
+	return parseOutputData(session, { fields: getAllFields(options, "session") });
+}
+function parseInputData(data, schema) {
+	const action = schema.action || "create";
+	const fields = schema.fields;
+	const parsedData = Object.assign(Object.create(null), null);
+	for (const key in fields) {
+		if (key in data) {
+			if (fields[key].input === false) {
+				if (fields[key].defaultValue !== void 0) {
+					if (action !== "update") {
+						parsedData[key] = fields[key].defaultValue;
+						continue;
+					}
+				}
+				if (data[key]) throw new APIError("BAD_REQUEST", { message: `${key} is not allowed to be set` });
+				continue;
+			}
+			if (fields[key].validator?.input && data[key] !== void 0) {
+				parsedData[key] = fields[key].validator.input["~standard"].validate(data[key]);
+				continue;
+			}
+			if (fields[key].transform?.input && data[key] !== void 0) {
+				parsedData[key] = fields[key].transform?.input(data[key]);
+				continue;
+			}
+			parsedData[key] = data[key];
+			continue;
+		}
+		if (fields[key].defaultValue !== void 0 && action === "create") {
+			parsedData[key] = fields[key].defaultValue;
+			continue;
+		}
+		if (fields[key].required && action === "create") throw new APIError("BAD_REQUEST", { message: `${key} is required` });
+	}
+	return parsedData;
+}
+function parseUserInput(options, user = {}, action) {
+	return parseInputData(user, {
+		fields: getAllFields(options, "user"),
+		action
+	});
+}
+function parseAdditionalUserInput(options, user) {
+	const schema = getAllFields(options, "user");
+	return parseInputData(user || {}, { fields: schema });
+}
+function parseAccountInput(options, account) {
+	return parseInputData(account, { fields: getAllFields(options, "account") });
+}
+function parseSessionInput(options, session) {
+	return parseInputData(session, { fields: getAllFields(options, "session") });
+}
+function mergeSchema(schema, newSchema) {
+	if (!newSchema) return schema;
+	for (const table in newSchema) {
+		const newModelName = newSchema[table]?.modelName;
+		if (newModelName) schema[table].modelName = newModelName;
+		for (const field in schema[table].fields) {
+			const newField = newSchema[table]?.fields?.[field];
+			if (!newField) continue;
+			schema[table].fields[field].fieldName = newField;
+		}
+	}
+	return schema;
+}
+
+//#endregion
+//#region src/utils/date.ts
+const getDate = (span, unit = "ms") => {
+	return new Date(Date.now() + (unit === "sec" ? span * 1e3 : span));
+};
+
+//#endregion
+export { parseAdditionalUserInput as a, parseSessionOutput as c, parseAccountOutput as i, parseUserInput as l, mergeSchema as n, parseInputData as o, parseAccountInput as r, parseSessionInput as s, getDate as t, parseUserOutput as u };

package/dist/db/index.d.mts

@@ -0,0 +1,7 @@
+import "../helper-tmxW3BHj.mjs";
+import { $t as mergeSchema, Jt as convertFromDB, Qt as toZodSchema, Sn as createFieldAttribute, Xt as getAdapter, Yt as convertToDB, Zt as FieldAttributeToSchema, _n as InferFieldsInput, an as parseSessionOutput, bn as InferValueType, cn as createInternalAdapter, dn as getMigrations, en as parseAccountInput, fn as matchType, gn as InferFieldsFromPlugins, hn as InferFieldsFromOptions, in as parseSessionInput, ln as getAuthTables, mn as InferAdditionalFieldsFromPluginOptions, nn as parseAdditionalUserInput, on as parseUserInput, pn as FieldAttributeToObject, qt as getWithHooks, rn as parseInputData, sn as parseUserOutput, tn as parseAccountOutput, un as getSchema, vn as InferFieldsInputClient, xn as PluginFieldAttribute, yn as InferFieldsOutput } from "../index-Cxi7TbLE.mjs";
+import "../types-B1OL7hyf.mjs";
+import "../index-65G5U5DB-DSdjzreF.mjs";
+import "../plugins-hFZT3hmK.mjs";
+export * from "@gatwech/core/db";
+export { FieldAttributeToObject, FieldAttributeToSchema, InferAdditionalFieldsFromPluginOptions, InferFieldsFromOptions, InferFieldsFromPlugins, InferFieldsInput, InferFieldsInputClient, InferFieldsOutput, InferValueType, PluginFieldAttribute, convertFromDB, convertToDB, createFieldAttribute, createInternalAdapter, getAdapter, getAuthTables, getMigrations, getSchema, getWithHooks, matchType, mergeSchema, parseAccountInput, parseAccountOutput, parseAdditionalUserInput, parseInputData, parseSessionInput, parseSessionOutput, parseUserInput, parseUserOutput, toZodSchema };

package/dist/db/index.mjs

@@ -0,0 +1,15 @@
+import "../utils-SOMB4Px5.mjs";
+import "../get-request-ip-DSjrEpGo.mjs";
+import "../json-D0TBLy4q.mjs";
+import "../crypto-Bb42eMrH.mjs";
+import "../jwt-CmxZAGe2.mjs";
+import { a as parseAdditionalUserInput, c as parseSessionOutput, i as parseAccountOutput, l as parseUserInput, n as mergeSchema, o as parseInputData, r as parseAccountInput, s as parseSessionInput, u as parseUserOutput } from "../date-Cx2yCiC4.mjs";
+import { a as createInternalAdapter, c as matchType, i as toZodSchema, l as getSchema, n as convertToDB, o as getWithHooks, r as getAdapter, s as getMigrations, t as convertFromDB, u as createFieldAttribute } from "../db-BrstmDhc.mjs";
+import "../dialect-CeddeGHf.mjs";
+import { t as getAuthTables } from "../get-tables-BQP7YW9c.mjs";
+import "../types-Bjn15Uy6.mjs";
+import "../misc-beA1w3XV.mjs";
+
+export * from "@gatwech/core/db"
+
+export { convertFromDB, convertToDB, createFieldAttribute, createInternalAdapter, getAdapter, getAuthTables, getMigrations, getSchema, getWithHooks, matchType, mergeSchema, parseAccountInput, parseAccountOutput, parseAdditionalUserInput, parseInputData, parseSessionInput, parseSessionOutput, parseUserInput, parseUserOutput, toZodSchema };