@sqrzro/server 2.0.0-bz.29 → 2.0.0-bz.30

package/dist/auth/LoginRequest.d.ts

@@ -1,4 +0,0 @@
-import Joi from 'joi';
-import type { LoginFormFields } from './interfaces';
-declare const LoginRequest: Joi.ObjectSchema<LoginFormFields>;
-export default LoginRequest;

package/dist/auth/LoginRequest.js

@@ -1,8 +0,0 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-import Joi from 'joi';
-import { createSchema } from '../forms/ValidationService';
-const LoginRequest = createSchema({
-    email: Joi.string().email({ minDomainSegments: 2, tlds: false }).required(),
-    password: Joi.string().min(8).required(),
-});
-export default LoginRequest;

package/dist/auth/MFARequest.d.ts

@@ -1,4 +0,0 @@
-import Joi from 'joi';
-import type { MFAFormFields } from './interfaces';
-declare const MFARequest: Joi.ObjectSchema<MFAFormFields>;
-export default MFARequest;

package/dist/auth/MFARequest.js

@@ -1,9 +0,0 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-import Joi from 'joi';
-import { createSchema } from '../forms/ValidationService';
-const MFARequest = createSchema({
-    token: Joi.string()
-        .pattern(/^[0-9]{6}$/u)
-        .required(),
-});
-export default MFARequest;

package/dist/auth/MFAService.d.ts

@@ -1,6 +0,0 @@
-import type { Errorable } from '@sqrzro/interfaces';
-import type { MFAFormFields, UserObject } from './interfaces';
-export declare function checkMFAEnabled(): boolean;
-export declare function generateMFA(name: string, email?: string): Promise<string | null>;
-export declare function checkUserHasMFA(user: UserObject): Promise<boolean>;
-export declare function handleMFAForm(formData: MFAFormFields): Promise<Errorable<boolean>>;

package/dist/auth/MFAService.js

@@ -1,105 +0,0 @@
-import { and, eq, isNotNull, isNull } from 'drizzle-orm';
-import qrcode from 'qrcode';
-import { authenticator } from 'otplib';
-import { db } from '../database/DatabaseService';
-import { authMFATable, authUserTable } from '../database/schema';
-import { submitForm } from '../forms/FormService';
-import MFARequest from './MFARequest';
-import { createUserSession, generateID, getSessionUser } from './SessionService';
-export function checkMFAEnabled() {
-    return process.env.AUTH_MFA_ENABLED !== 'false';
-}
-export async function generateMFA(name, email) {
-    if (!checkMFAEnabled() || !email) {
-        return null;
-    }
-    const [user] = await db
-        .select()
-        .from(authUserTable)
-        .where(eq(authUserTable.email, email))
-        .limit(1);
-    if (!user) {
-        return null;
-    }
-    const secret = authenticator.generateSecret();
-    const otpauth = authenticator.keyuri(email, name, secret);
-    // Delete all the unverified MFA entries for this user
-    await db
-        .delete(authMFATable)
-        .where(and(eq(authMFATable.userId, user.id), isNull(authMFATable.verifiedAt)));
-    // Add the new MFA entry
-    await db.insert(authMFATable).values({
-        id: generateID(),
-        name: 'Default',
-        secret,
-        userId: user.id,
-    });
-    return new Promise((resolve, reject) => {
-        qrcode.toDataURL(otpauth, { rendererOpts: { quality: 1 }, margin: 0, scale: 2 }, (err, data) => {
-            if (err) {
-                reject(err);
-            }
-            resolve(data);
-        });
-    });
-}
-export async function checkUserHasMFA(user) {
-    if (!checkMFAEnabled()) {
-        return false;
-    }
-    const [mfa] = await db
-        .select()
-        .from(authMFATable)
-        .where(and(eq(authMFATable.userId, user.id), isNotNull(authMFATable.verifiedAt)))
-        .limit(1);
-    return Boolean(mfa);
-}
-async function markAsVerified(userID) {
-    if (!checkMFAEnabled()) {
-        return;
-    }
-    await db
-        .update(authMFATable)
-        .set({ verifiedAt: new Date() })
-        .where(eq(authMFATable.userId, userID));
-}
-async function validateUserToken(userID, token) {
-    if (!checkMFAEnabled()) {
-        return false;
-    }
-    const [mfa] = await db
-        .select()
-        .from(authMFATable)
-        .where(eq(authMFATable.userId, userID))
-        .limit(1);
-    if (!mfa) {
-        return false;
-    }
-    return authenticator.check(token, mfa.secret);
-}
-async function handleMFA(formData) {
-    if (!checkMFAEnabled()) {
-        return false;
-    }
-    const user = await getSessionUser();
-    if (!user) {
-        return false;
-    }
-    const isValid = await validateUserToken(user.id, formData.token);
-    if (!isValid) {
-        return false;
-    }
-    await markAsVerified(user.id);
-    return createUserSession(user.id, 'AUTHED');
-}
-export async function handleMFAForm(formData) {
-    if (!checkMFAEnabled()) {
-        return [null, new Error('MFA is not enabled')];
-    }
-    const response = await submitForm({
-        fn: handleMFA,
-        formData,
-        request: MFARequest,
-    });
-    return response;
-}

package/dist/auth/PasswordRequest.d.ts

@@ -1,4 +0,0 @@
-import Joi from 'joi';
-import type { PasswordFormFields } from './interfaces';
-declare const PasswordRequest: Joi.ObjectSchema<PasswordFormFields>;
-export default PasswordRequest;

package/dist/auth/PasswordRequest.js

@@ -1,12 +0,0 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-import Joi from 'joi';
-import { createSchema } from '../forms/ValidationService';
-const PasswordRequest = createSchema({
-    email: Joi.string().max(60).email({ minDomainSegments: 2, tlds: false }).required().messages({
-        'any.required': 'Please provide your email address, so we can send you a reset link',
-        'string.empty': 'Please provide your email address, so we can send you a reset link',
-        'string.email': 'Please make sure your email address is valid',
-        'string.max': 'Please make sure your email address is valid',
-    }),
-});
-export default PasswordRequest;

package/dist/auth/PasswordResetRequest.d.ts

@@ -1,4 +0,0 @@
-import Joi from 'joi';
-import type { PasswordResetFormFields } from './interfaces';
-declare const PasswordResetRequest: Joi.ObjectSchema<PasswordResetFormFields>;
-export default PasswordResetRequest;

package/dist/auth/PasswordResetRequest.js

@@ -1,13 +0,0 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-import Joi from 'joi';
-import { createSchema } from '../forms/ValidationService';
-const PasswordResetRequest = createSchema({
-    token: Joi.string()
-        .pattern(/[a-z0-9]{40}/u)
-        .required(),
-    password: Joi.string().required().messages({
-        'any.required': 'Please provide your new password',
-        'string.empty': 'Please provide your new password',
-    }),
-});
-export default PasswordResetRequest;

package/dist/auth/PasswordService.d.ts

@@ -1,8 +0,0 @@
-type PasswordRule = 'lower' | 'min' | 'number' | 'symbol' | 'upper';
-export type PasswordRuleObject = Partial<Record<PasswordRule, number>>;
-type PasswordValidityObject = Record<PasswordRule, boolean>;
-export declare function hashPassword(password: string): Promise<string>;
-export declare function verifyPassword(data?: string, encrypted?: string): Promise<boolean>;
-export declare function getPasswordComplexity(password: string, rules?: Partial<PasswordRuleObject>): Promise<Partial<PasswordValidityObject>>;
-export declare function checkPasswordComplexity(password: string, rules?: Partial<PasswordRuleObject>): Promise<Partial<boolean>>;
-export {};

package/dist/auth/PasswordService.js

@@ -1,54 +0,0 @@
-import bcrypt from 'bcryptjs';
-const PW_SALT_ROUNDS = 12;
-const PASSWORD_RULES = {
-    min: 8,
-    upper: 1,
-    lower: 1,
-    number: 1,
-    symbol: 1,
-};
-function checkPasswordMin(password, value) {
-    return password.length >= value;
-}
-function checkPasswordUpper(password, value) {
-    return password.replace(/[^A-Z]/gu, '').length >= value;
-}
-function checkPasswordLower(password, value) {
-    return password.replace(/[^a-z]/gu, '').length >= value;
-}
-function checkPasswordNumber(password, value) {
-    return password.replace(/[^0-9]/gu, '').length >= value;
-}
-function checkPasswordSymbol(password, value) {
-    return password.replace(/[^$]/gu, '').length >= value;
-}
-const PASSWORD_FUNCTIONS = {
-    min: checkPasswordMin,
-    upper: checkPasswordUpper,
-    lower: checkPasswordLower,
-    number: checkPasswordNumber,
-    symbol: checkPasswordSymbol,
-};
-export async function hashPassword(password) {
-    const hash = await bcrypt.hash(password, PW_SALT_ROUNDS);
-    return hash;
-}
-export async function verifyPassword(data, encrypted) {
-    if (!data || !encrypted) {
-        return false;
-    }
-    const verified = await bcrypt.compare(data, encrypted);
-    return verified;
-}
-export async function getPasswordComplexity(password, rules = PASSWORD_RULES) {
-    const entries = Object.entries(rules);
-    const validity = entries.reduce((acc, [rule, value]) => {
-        acc[rule] = PASSWORD_FUNCTIONS[rule](password, value);
-        return acc;
-    }, {});
-    return Promise.resolve(validity);
-}
-export async function checkPasswordComplexity(password, rules = PASSWORD_RULES) {
-    const validity = await getPasswordComplexity(password, rules);
-    return Promise.resolve(Object.values(validity).every(Boolean));
-}

package/dist/auth/SessionService.d.ts

@@ -1,42 +0,0 @@
-import { Lucia } from 'lucia';
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import type { Scope } from '../database/schema';
-interface ScopeData {
-    allowedRoute?: string;
-    redirectOnAuth?: string;
-    redirectOnUnauth?: string;
-}
-export type ScopeObject = Record<Scope, ScopeData>;
-interface DatabaseSessionAttributes {
-    scope: Scope;
-}
-interface DatabaseUserAttributes {
-    email: string;
-    role: number;
-}
-declare module 'lucia' {
-    interface Register {
-        Lucia: typeof lucia;
-        DatabaseSessionAttributes: DatabaseSessionAttributes;
-        DatabaseUserAttributes: DatabaseUserAttributes;
-    }
-}
-export declare const lucia: Lucia<DatabaseSessionAttributes, DatabaseUserAttributes>;
-export declare function generateID<T extends string = string>(prefix?: string, length?: number): T;
-export declare function invalidateSession(id: string): Promise<void>;
-export declare function invalidateUserSessions(id: string): Promise<void>;
-export declare function createUserSession(id: string, scope?: Scope): Promise<boolean>;
-export declare function getSessionID(): string | null;
-export declare function checkSessionExists(): boolean;
-export declare function getSessionUser(): Promise<{
-    id: string;
-    email: string;
-    role: number;
-} | null>;
-export declare function checkRouteAllowed(pathname: string, route?: string): boolean;
-export declare function getScopes(): Promise<ScopeObject>;
-export declare function getScopeByID(id: Scope): Promise<ScopeData>;
-export declare function setScopes(customScopes?: Partial<ScopeObject>): Promise<void>;
-export declare function handleSession(request: NextRequest, customScopes?: Partial<ScopeObject>): Promise<NextResponse>;
-export {};

package/dist/auth/SessionService.js

@@ -1,127 +0,0 @@
-import { DrizzlePostgreSQLAdapter } from '@lucia-auth/adapter-drizzle';
-import { Lucia, generateId } from 'lucia';
-import { cookies } from 'next/headers';
-import { NextResponse } from 'next/server';
-import { match } from 'path-to-regexp';
-import { getAllowedRoles } from './AuthService';
-import { db } from '../database/DatabaseService';
-import { authSessionTable, authUserTable } from '../database/schema';
-import { getFromCache, setToCache } from '../cache/CacheService';
-import { getOrigin } from '../url/URLService';
-import { getFromObject } from '@sqrzro/utility';
-const DEFAULT_REDIRECT = '/auth/login';
-const ID_LENGTH = 16;
-const DEFAULT_SCOPES = {
-    ANON: {
-        allowedRoute: '/auth/(login|password)',
-        redirectOnUnauth: DEFAULT_REDIRECT,
-    },
-    MFA: {
-        allowedRoute: '/auth/mfa',
-        redirectOnUnauth: '/auth/mfa',
-    },
-    AUTHED: {
-        allowedRoute: '*',
-        redirectOnAuth: '/',
-    },
-};
-const adapter = new DrizzlePostgreSQLAdapter(db, authSessionTable, authUserTable);
-export const lucia = new Lucia(adapter, {
-    sessionCookie: {
-        attributes: {
-            secure: process.env.NODE_ENV === 'production',
-        },
-        name: process.env.AUTH_COOKIE_NAME || 'auth_session',
-    },
-    getSessionAttributes: (attributes) => ({
-        scope: attributes.scope,
-    }),
-    getUserAttributes: (attributes) => ({
-        email: attributes.email,
-        role: attributes.role,
-    }),
-});
-export function generateID(prefix = '', length = ID_LENGTH) {
-    return `${prefix ? `${prefix}_` : ''}${generateId(length)}`;
-}
-export async function invalidateSession(id) {
-    const cookie = lucia.createBlankSessionCookie();
-    cookies().set(cookie.name, cookie.value, cookie.attributes);
-    return lucia.invalidateSession(id);
-}
-export async function invalidateUserSessions(id) {
-    return lucia.invalidateUserSessions(id);
-}
-export async function createUserSession(id, scope = 'ANON') {
-    const session = await lucia.createSession(id, { scope });
-    const sessionCookie = lucia.createSessionCookie(session.id);
-    cookies().set(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
-    return true;
-}
-export function getSessionID() {
-    return cookies().get(lucia.sessionCookieName)?.value ?? null;
-}
-export function checkSessionExists() {
-    return Boolean(getSessionID());
-}
-export async function getSessionUser() {
-    const sessionID = getSessionID();
-    if (!sessionID) {
-        return null;
-    }
-    const { user } = await lucia.validateSession(sessionID);
-    if (!user?.role || !getAllowedRoles().includes(user.role)) {
-        return null;
-    }
-    return getFromObject(user, ['id', 'email', 'role']);
-}
-export function checkRouteAllowed(pathname, route) {
-    if (!route) {
-        return false;
-    }
-    if (route === '*') {
-        return true;
-    }
-    return match(route)(pathname) !== false;
-}
-export async function getScopes() {
-    const scopes = await getFromCache(`${getOrigin()}:scopes`);
-    return scopes ? JSON.parse(scopes) : DEFAULT_SCOPES;
-}
-export async function getScopeByID(id) {
-    const scopes = await getScopes();
-    return scopes[id];
-}
-export async function setScopes(customScopes) {
-    const scopes = {
-        ANON: {
-            ...DEFAULT_SCOPES.ANON,
-            ...customScopes?.ANON,
-        },
-        MFA: {
-            ...DEFAULT_SCOPES.MFA,
-            ...customScopes?.MFA,
-        },
-        AUTHED: {
-            ...DEFAULT_SCOPES.AUTHED,
-            ...customScopes?.AUTHED,
-        },
-    };
-    return setToCache(`${getOrigin()}:scopes`, JSON.stringify(scopes));
-}
-async function validateSessionFromID(sessionID, pathname) {
-    const scopes = await getScopes();
-    const { session, user } = await lucia.validateSession(sessionID);
-    const scope = scopes[session && getAllowedRoles().includes(user?.role) ? session.scope : 'ANON'];
-    return checkRouteAllowed(pathname, scope.allowedRoute)
-        ? null
-        : scope.redirectOnUnauth || DEFAULT_REDIRECT;
-}
-export async function handleSession(request, customScopes) {
-    const sessionID = request.nextUrl.searchParams.get('id') || '';
-    const pathname = request.nextUrl.searchParams.get('pathname') || '/';
-    await setScopes(customScopes);
-    return NextResponse.json({
-        redirect: await validateSessionFromID(sessionID, pathname),
-    });
-}

package/dist/auth/interfaces.d.ts

@@ -1,20 +0,0 @@
-export interface LoginFormFields {
-    email: string;
-    password: string;
-}
-export interface MFAFormFields {
-    token: string;
-}
-export interface PasswordFormFields {
-    email: string;
-}
-export interface PasswordResetFormFields {
-    password: string;
-    token: string;
-}
-export interface UserObject {
-    id: string;
-    email: string;
-    password?: string | null;
-    role?: number;
-}

package/dist/auth/interfaces.js

@@ -1 +0,0 @@
-export {};

package/dist/cache/CacheService.d.ts

@@ -1,2 +0,0 @@
-export declare function getFromCache(key: string): Promise<string | null>;
-export declare function setToCache(key: string, value: string): Promise<void>;

package/dist/cache/CacheService.js

@@ -1,27 +0,0 @@
-import { createClient } from 'redis';
-let client = null;
-function isLocalhost(url) {
-    return url.includes('localhost') || url.includes('127.0.0.1');
-}
-async function getClient() {
-    if (!process.env.REDIS_URL) {
-        throw new Error('REDIS_URL is not defined. Access to the cache is not possible.');
-    }
-    if (client) {
-        return client;
-    }
-    client = createClient({
-        socket: {
-            tls: !isLocalhost(process.env.REDIS_URL),
-        },
-        url: process.env.REDIS_URL,
-    });
-    await client.connect();
-    return client;
-}
-export async function getFromCache(key) {
-    return (await getClient()).get(key);
-}
-export async function setToCache(key, value) {
-    await (await getClient()).set(key, value);
-}

package/dist/database/DatabaseService.d.ts

@@ -1,7 +0,0 @@
-import type { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-declare global {
-    var szdb: ReturnType<typeof createSingleton> | undefined;
-}
-declare function createSingleton(): PostgresJsDatabase;
-export declare const db: PostgresJsDatabase;
-export {};

package/dist/database/DatabaseService.js

@@ -1,12 +0,0 @@
-import { drizzle } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
-function createSingleton() {
-    if (!process.env.DATABASE_URL) {
-        throw new Error('DATABASE_URL is not defined');
-    }
-    return drizzle(postgres(process.env.DATABASE_URL, { prepare: false }));
-}
-export const db = globalThis.szdb ?? createSingleton();
-if (!process.env.VERCEL_ENV) {
-    globalThis.szdb = db;
-}

package/dist/forms/FormService.d.ts

@@ -1,18 +0,0 @@
-import type { SerializedErrorable } from '@sqrzro/interfaces';
-import type Joi from 'joi';
-import { NextResponse } from 'next/server';
-import ValidationError from './ValidationError';
-interface SubmitFormArgs<F extends object> {
-    formData: F;
-    onSuccess?: (model: F) => Promise<void> | void;
-    onValidationError?: (error: ValidationError) => void;
-    request?: Joi.ObjectSchema<F>;
-}
-interface SubmitFormArgsWithFn<F extends object, M> extends Omit<SubmitFormArgs<F>, 'onSuccess'> {
-    fn: (data: F) => Promise<M | null>;
-    onSuccess?: (model: M) => Promise<void> | void;
-}
-export declare function submitForm<F extends object>(args: SubmitFormArgs<F>): Promise<SerializedErrorable<F>>;
-export declare function submitForm<F extends object, M>(args: SubmitFormArgsWithFn<F, M>): Promise<SerializedErrorable<M>>;
-export declare function submitAPIRequest<F extends object, M>(args: SubmitFormArgsWithFn<F, M>): Promise<[M, null] | [null, NextResponse]>;
-export {};

package/dist/forms/FormService.js

@@ -1,98 +0,0 @@
-/* eslint-disable max-statements */
-import { NextResponse } from 'next/server';
-import ValidationError from './ValidationError';
-import { validateSchema } from './ValidationService';
-function serializeError(err) {
-    return {
-        cause: err.cause,
-        message: err.message,
-        name: err.name,
-        stack: err.stack,
-    };
-}
-function hasFn(args) {
-    return Boolean(Object.prototype.hasOwnProperty.call(args, 'fn'));
-}
-export async function submitForm(args) {
-    let data = { ...args.formData };
-    if (args.request) {
-        const [validated, validationError] = await validateSchema(args.formData, args.request);
-        if (validationError !== null) {
-            if (validationError instanceof ValidationError) {
-                args.onValidationError?.(validationError);
-            }
-            return [null, serializeError(validationError)];
-        }
-        data = validated;
-    }
-    if (!hasFn(args)) {
-        try {
-            await args.onSuccess?.(data);
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                return [null, serializeError(err)];
-            }
-            return [
-                null,
-                serializeError(new Error('The submitForm onSuccess function encountered an unknown error')),
-            ];
-        }
-        return [data, null];
-    }
-    let model = null;
-    try {
-        model = await args.fn(data);
-    }
-    catch (err) {
-        if (err instanceof ValidationError) {
-            args.onValidationError?.(err);
-            return [null, serializeError(err)];
-        }
-        if (err instanceof Error) {
-            return [null, serializeError(err)];
-        }
-        return [
-            null,
-            serializeError(new Error('The function supplied to submitForm encountered an unknown error')),
-        ];
-    }
-    if (!model) {
-        return [
-            null,
-            serializeError(new Error('No model has been returned from the function supplied to submitForm')),
-        ];
-    }
-    try {
-        await args.onSuccess?.(model);
-    }
-    catch (err) {
-        if (err instanceof Error) {
-            return [null, serializeError(err)];
-        }
-        return [
-            null,
-            serializeError(new Error('The submitForm onSuccess function encountered an unknown error')),
-        ];
-    }
-    return [model, null];
-}
-export async function submitAPIRequest(args) {
-    const [response, error] = await submitForm(args);
-    if (error !== null) {
-        if (error.name === 'ValidationError') {
-            try {
-                const errors = JSON.parse(error.message);
-                return [null, NextResponse.json(errors, { status: 422 })];
-            }
-            catch (err) {
-                return [
-                    null,
-                    NextResponse.json({ message: 'An unknown error occured' }, { status: 500 }),
-                ];
-            }
-        }
-        return [null, NextResponse.json({ message: error.message }, { status: 500 })];
-    }
-    return [response, null];
-}

package/dist/forms/ImageService.d.ts

@@ -1,7 +0,0 @@
-import type { Errorable } from '@sqrzro/interfaces';
-interface ImageValidationConfig {
-    maxSize?: number;
-    types?: string[];
-}
-export declare function validateImage(image: File | null, config?: ImageValidationConfig): Promise<Errorable<File>>;
-export {};

package/dist/forms/ImageService.js

@@ -1,19 +0,0 @@
-'use server';
-const DEFAULT_TYPES = ['image/png', 'image/jpeg', 'image/jpg'];
-// 5MB
-const DEFAULT_MAX_SIZE = 5242880;
-export async function validateImage(image, config) {
-    if (!image) {
-        return Promise.resolve([null, new Error('IMAGE_UNDEFINED')]);
-    }
-    if (!(image instanceof File)) {
-        return Promise.resolve([null, new Error('IMAGE_NOT_VALID')]);
-    }
-    if (!(config?.types || DEFAULT_TYPES).includes(image.type)) {
-        return Promise.resolve([null, new Error('IMAGE_TYPE_NOT_VALID')]);
-    }
-    if (image.size > (config?.maxSize || DEFAULT_MAX_SIZE)) {
-        return Promise.resolve([null, new Error('IMAGE_TOO_HEAVY')]);
-    }
-    return Promise.resolve([image, null]);
-}

package/dist/forms/ValidationError.d.ts

@@ -1,4 +0,0 @@
-declare class ValidationError extends Error {
-    constructor(messages: Record<string, string>);
-}
-export default ValidationError;

package/dist/forms/ValidationError.js

@@ -1,7 +0,0 @@
-class ValidationError extends Error {
-    constructor(messages) {
-        super(JSON.stringify(messages));
-        this.name = 'ValidationError';
-    }
-}
-export default ValidationError;