@sqrzro/server 2.0.0-bz.9 → 2.0.0-r19.3

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(length = ID_LENGTH) {
-    return 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,14 +0,0 @@
-import { createClient } from 'redis';
-async function getClient() {
-    const client = createClient();
-    await client.connect();
-    return client;
-}
-export async function getFromCache(key) {
-    const client = await getClient();
-    return client.get(key);
-}
-export async function setToCache(key, value) {
-    const client = await getClient();
-    await client.set(key, value);
-}

package/dist/database/DatabaseService.d.ts

@@ -1,7 +0,0 @@
-import type { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-declare global {
-    var db: 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.db ?? createSingleton();
-if (!process.env.VERCEL_ENV) {
-    globalThis.db = db;
-}

package/dist/forms/FormService.d.ts

@@ -1,16 +0,0 @@
-import type { Errorable } from '@sqrzro/interfaces';
-import type Joi from 'joi';
-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<Errorable<F>>;
-export declare function submitForm<F extends object, M>(args: SubmitFormArgsWithFn<F, M>): Promise<Errorable<M>>;
-export {};

package/dist/forms/FormService.js

@@ -1,78 +0,0 @@
-/* eslint-disable max-statements */
-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];
-}

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;

package/dist/forms/ValidationService.d.ts

@@ -1,20 +0,0 @@
-import type { Errorable } from '@sqrzro/interfaces';
-import Joi from 'joi';
-export declare function validate(): typeof Joi;
-export type ValidationCustomHelpers<V = any> = Joi.CustomHelpers<V>;
-export type ValidationExternalHelpers<V = any> = Joi.ExternalHelpers<V>;
-export type ValidationErrorReport = Joi.ErrorReport;
-/**
- * This function takes FormData and a schema. It then attempts to transform the FormData into an
- * object that matches `T`. This is because the FormData object is not typed and we want to be able
- * to validate it properly typed.
- *
- * Once transformed, the object is validated against the schema. This will result in either a
- * properly typed `T` object or an array of validation errors.
- * @param formData
- * @param validation
- * @returns
- */
-export declare function validateSchema<T>(formData: T, validation: Joi.ObjectSchema<T>): Promise<Errorable<T>>;
-export declare function createSchema<T>(schema: Joi.SchemaMap<T, true>): Joi.ObjectSchema<T>;
-export declare function extendSchema<T, U extends T>(schema: Joi.ObjectSchema<T>, appends: Joi.PartialSchemaMap<U>): Joi.ObjectSchema<U>;

package/dist/forms/ValidationService.js

@@ -1,59 +0,0 @@
-import Joi from 'joi';
-import lang from './lang';
-import ValidationError from './ValidationError';
-export function validate() {
-    return Joi;
-}
-function getErrorMessages() {
-    return Object.entries(lang).reduce((acc, [key, value]) => {
-        if (!value) {
-            return acc;
-        }
-        return {
-            ...acc,
-            [key]: value,
-        };
-    }, {});
-}
-function transformErrors(error) {
-    const messages = error.details.reduce((acc, cur) => ({
-        ...acc,
-        [cur.path.join('.')]: cur.message.replace(/"/gu, ''),
-    }), {});
-    return new ValidationError(messages);
-}
-/**
- * This function takes FormData and a schema. It then attempts to transform the FormData into an
- * object that matches `T`. This is because the FormData object is not typed and we want to be able
- * to validate it properly typed.
- *
- * Once transformed, the object is validated against the schema. This will result in either a
- * properly typed `T` object or an array of validation errors.
- * @param formData
- * @param validation
- * @returns
- */
-export async function validateSchema(formData, validation) {
-    try {
-        const validated = await validation.validateAsync(formData, {
-            abortEarly: false,
-            messages: getErrorMessages(),
-        });
-        return [validated, null];
-    }
-    catch (err) {
-        if (err instanceof Joi.ValidationError) {
-            return [null, transformErrors(err)];
-        }
-        if (err instanceof Error) {
-            return [null, err];
-        }
-        return [null, new Error('Unknown validation error occured')];
-    }
-}
-export function createSchema(schema) {
-    return Joi.object(schema);
-}
-export function extendSchema(schema, appends) {
-    return schema.append(appends);
-}

package/dist/forms/lang.d.ts

@@ -1,2 +0,0 @@
-declare const messages: Record<string, string>;
-export default messages;

package/dist/forms/lang.js

@@ -1,115 +0,0 @@
-const messages = {
-    'alternatives.all': '',
-    'alternatives.any': '',
-    'alternatives.match': '',
-    'alternatives.one': '',
-    'alternatives.types': '',
-    'any.custom': '',
-    'any.default': '',
-    'any.failover': '',
-    'any.invalid': '',
-    'any.only': '',
-    'any.ref': '',
-    'any.required': '{{#label}} is required',
-    'any.unknown': '',
-    'array.base': '',
-    'array.excludes': '',
-    'array.includesRequiredBoth': '',
-    'array.includesRequiredKnowns': '',
-    'array.includesRequiredUnknowns': '',
-    'array.includes': '',
-    'array.length': '',
-    'array.max': '',
-    'array.min': '',
-    'array.orderedLength': '',
-    'array.sort': '',
-    'array.sort.mismatching': '',
-    'array.sort.unsupported': '',
-    'array.sparse': '',
-    'array.unique': '',
-    'array.hasKnown': '',
-    'array.hasUnknown': '',
-    'binary.base': '',
-    'binary.length': '',
-    'binary.max': '',
-    'binary.min': '',
-    'boolean.base': '',
-    'date.base': '',
-    'date.format': '',
-    'date.greater': '',
-    'date.less': '',
-    'date.max': '',
-    'date.min': '',
-    'date.strict': '',
-    'function.arity': '',
-    'function.class': '',
-    'function.maxArity': '',
-    'function.minArity': '',
-    'number.base': '{{#label}} should be a number',
-    'number.greater': '',
-    'number.infinity': '',
-    'number.integer': '',
-    'number.less': '',
-    'number.max': '',
-    'number.min': '{{#label}} should be greater than or equal to {{#limit}}',
-    'number.multiple': '',
-    'number.negative': '',
-    'number.port': '',
-    'number.positive': '',
-    'number.precision': '',
-    'number.unsafe': '',
-    'object.unknown': '',
-    'object.and': '',
-    'object.assert': '',
-    'object.base': '',
-    'object.length': '',
-    'object.max': '',
-    'object.min': '',
-    'object.missing': '',
-    'object.nand': '',
-    'object.pattern.match': '',
-    'object.refType': '',
-    'object.regex': '',
-    'object.rename.multiple': '',
-    'object.rename.override': '',
-    'object.schema': '',
-    'object.instance': '',
-    'object.with': '',
-    'object.without': '',
-    'object.xor': '',
-    'object.oxor': '',
-    'string.alphanum': '',
-    'string.base64': '',
-    'string.base': '',
-    'string.creditCard': '',
-    'string.dataUri': '',
-    'string.domain': '',
-    'string.email': '',
-    'string.empty': '{{#label}} is required',
-    'string.guid': '',
-    'string.hexAlign': '',
-    'string.hex': '',
-    'string.hostname': '',
-    'string.ipVersion': '',
-    'string.ip': '',
-    'string.isoDate': '',
-    'string.isoDuration': '',
-    'string.length': '',
-    'string.lowercase': '',
-    'string.max': '',
-    'string.min': '',
-    'string.normalize': '',
-    'string.pattern.base': '',
-    'string.pattern.name': '',
-    'string.pattern.invert.base': '',
-    'string.pattern.invert.name': '',
-    'string.token': '',
-    'string.trim': '',
-    'string.uppercase': '',
-    'string.uri': '',
-    'string.uriCustomScheme': '',
-    'string.uriRelativeOnly': '',
-    'symbol.base': '',
-    'symbol.map': '',
-};
-export default messages;

package/dist/lists/ListService.js

@@ -1,28 +0,0 @@
-import { getFromObject } from '@sqrzro/utility';
-const DEFAULT_SORT = 'id';
-const DEFAULT_DIR = 'asc';
-const DEFAULT_PAGE = 1;
-const DEFAULT_LIMIT = 10;
-function createPaginationArgs(page) {
-    return { skip: (page - 1) * DEFAULT_LIMIT, take: DEFAULT_LIMIT };
-}
-function createFindManyArgs(searchParams, allowedFilters = []) {
-    const { dir, page, sort, ...filters } = searchParams || {};
-    return {
-        ...createPaginationArgs(page ? parseInt(page, 10) : DEFAULT_PAGE),
-        orderBy: { [sort || DEFAULT_SORT]: dir || DEFAULT_DIR },
-        where: getFromObject(filters, allowedFilters),
-    };
-}
-export async function getList({ allowedFilters, fn, searchParams, }) {
-    try {
-        const args = createFindManyArgs(searchParams, allowedFilters);
-        return [await fn(args), null];
-    }
-    catch (err) {
-        if (err instanceof Error) {
-            return [null, err];
-        }
-        return [null, new Error('[getList] An unknown error occurred')];
-    }
-}

package/dist/mail/MailService.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="react" />
-type MailFn<T extends object> = () => Promise<{
-    subject: string;
-    template: (data: T) => React.ReactElement;
-}>;
-export declare function createMail<T extends object>(subject: string, template: (data: T) => React.ReactElement): Promise<MailFn<T>>;
-export declare function getMail<T extends object>(mail: MailFn<T>, data: T): Promise<{
-    subject: string;
-    html: string;
-}>;
-export declare function sendMail<T extends object>(mail: Promise<MailFn<T>>, data: T, to: string): Promise<boolean>;
-export {};

package/dist/mail/MailService.js

@@ -1,55 +0,0 @@
-export async function createMail(subject, template) {
-    return Promise.resolve(async () => Promise.resolve({ subject, template }));
-}
-export async function getMail(mail, data) {
-    const { subject, template } = await mail();
-    const ReactDOMServer = (await import('react-dom/server')).default;
-    return {
-        subject,
-        html: ReactDOMServer.renderToStaticMarkup(template(data)),
-    };
-}
-function getSenderDetails() {
-    if (!process.env.MAIL_FROM) {
-        throw new Error('Mail from address has not been set');
-    }
-    const matches = /^(?<name>[^<]+)<(?<email>[^>]+)>$/u.exec(process.env.MAIL_FROM);
-    if (!matches?.groups?.name || !matches?.groups?.email) {
-        throw new Error('Mail from address is not the correct format. It should be "Name <email>".');
-    }
-    return {
-        email: matches.groups.email.trim(),
-        name: matches.groups.name.trim(),
-    };
-}
-export async function sendMail(mail, data, to) {
-    if (!process.env.MAIL_API_URL) {
-        throw new Error('Mail URL has not been set');
-    }
-    if (!process.env.MAIL_API_KEY) {
-        throw new Error('Mail API key has not been set');
-    }
-    const from = getSenderDetails();
-    const { subject, html } = await getMail(await mail, data);
-    try {
-        const response = await fetch(process.env.MAIL_API_URL, {
-            method: 'POST',
-            headers: { 'Api-Token': process.env.MAIL_API_KEY, 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                from,
-                html,
-                subject,
-                to: [{ email: to }],
-            }),
-        });
-        const json = (await response.json());
-        return json.success;
-    }
-    catch (err) {
-        /* eslint-disable-next-line no-console */
-        console.log('err', err);
-        /* eslint-disable-next-line no-warning-comments */
-        // TODO: Log error to Sentry
-        return false;
-    }
-}