@sqrzro/server 2.0.0-bz.12 → 2.0.0-bz.14

package/dist/auth/interfaces.d.ts

@@ -0,0 +1,20 @@
+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

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

package/dist/cache/CacheService.d.ts

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

package/dist/cache/CacheService.js

@@ -0,0 +1,14 @@
+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/cache/index.d.ts

@@ -0,0 +1 @@
+export * from './CacheService';

package/dist/cache/index.js

@@ -0,0 +1 @@
+export * from './CacheService';

package/dist/database/DatabaseService.d.ts

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

@@ -0,0 +1,12 @@
+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/{schema.d.ts → database/schema.d.ts}

@@ -1,14 +1,12 @@
-import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-
-declare const mfaType: drizzle_orm_pg_core.PgEnum<["TOTP", "HARDWARE"]>;
-declare const scope: drizzle_orm_pg_core.PgEnum<["ANON", "MFA", "AUTHED"]>;
-type Scope = (typeof scope.enumValues)[number];
-declare const authSchema: drizzle_orm_pg_core.PgSchema<"auth">;
-declare const authUserTable: drizzle_orm_pg_core.PgTableWithColumns<{
+export declare const mfaType: import("drizzle-orm/pg-core").PgEnum<["TOTP", "HARDWARE"]>;
+export declare const scope: import("drizzle-orm/pg-core").PgEnum<["ANON", "MFA", "AUTHED"]>;
+export type Scope = (typeof scope.enumValues)[number];
+export declare const authSchema: import("drizzle-orm/pg-core").PgSchema<"auth">;
+export declare const authUserTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "user_credentials";
     schema: "auth";
     columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
+        id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
             tableName: "user_credentials";
             dataType: "string";
@@ -20,7 +18,7 @@ declare const authUserTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        email: drizzle_orm_pg_core.PgColumn<{
+        email: import("drizzle-orm/pg-core").PgColumn<{
             name: "email";
             tableName: "user_credentials";
             dataType: "string";
@@ -32,7 +30,7 @@ declare const authUserTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        password: drizzle_orm_pg_core.PgColumn<{
+        password: import("drizzle-orm/pg-core").PgColumn<{
             name: "password";
             tableName: "user_credentials";
             dataType: "string";
@@ -44,7 +42,7 @@ declare const authUserTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        role: drizzle_orm_pg_core.PgColumn<{
+        role: import("drizzle-orm/pg-core").PgColumn<{
             name: "role";
             tableName: "user_credentials";
             dataType: "number";
@@ -59,12 +57,12 @@ declare const authUserTable: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-type AuthUser = typeof authUserTable.$inferSelect;
-declare const authSessionTable: drizzle_orm_pg_core.PgTableWithColumns<{
+export type AuthUser = typeof authUserTable.$inferSelect;
+export declare const authSessionTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "sessions";
     schema: "auth";
     columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
+        id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
             tableName: "sessions";
             dataType: "string";
@@ -76,7 +74,7 @@ declare const authSessionTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        userId: drizzle_orm_pg_core.PgColumn<{
+        userId: import("drizzle-orm/pg-core").PgColumn<{
             name: "userId";
             tableName: "sessions";
             dataType: "string";
@@ -88,7 +86,7 @@ declare const authSessionTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        scope: drizzle_orm_pg_core.PgColumn<{
+        scope: import("drizzle-orm/pg-core").PgColumn<{
             name: "scope";
             tableName: "sessions";
             dataType: "string";
@@ -100,7 +98,7 @@ declare const authSessionTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: ["ANON", "MFA", "AUTHED"];
             baseColumn: never;
         }, {}, {}>;
-        expiresAt: drizzle_orm_pg_core.PgColumn<{
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "expiresAt";
             tableName: "sessions";
             dataType: "date";
@@ -115,12 +113,12 @@ declare const authSessionTable: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-type AuthSession = typeof authSessionTable.$inferSelect;
-declare const authResetTable: drizzle_orm_pg_core.PgTableWithColumns<{
+export type AuthSession = typeof authSessionTable.$inferSelect;
+export declare const authResetTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "resets";
     schema: "auth";
     columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
+        id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
             tableName: "resets";
             dataType: "string";
@@ -132,7 +130,7 @@ declare const authResetTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        userId: drizzle_orm_pg_core.PgColumn<{
+        userId: import("drizzle-orm/pg-core").PgColumn<{
             name: "userId";
             tableName: "resets";
             dataType: "string";
@@ -144,7 +142,7 @@ declare const authResetTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        expiresAt: drizzle_orm_pg_core.PgColumn<{
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "expiresAt";
             tableName: "resets";
             dataType: "date";
@@ -159,12 +157,12 @@ declare const authResetTable: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-type AuthReset = typeof authResetTable.$inferSelect;
-declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
+export type AuthReset = typeof authResetTable.$inferSelect;
+export declare const authMFATable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "mfas";
     schema: "auth";
     columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
+        id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
             tableName: "mfas";
             dataType: "string";
@@ -176,7 +174,7 @@ declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        name: drizzle_orm_pg_core.PgColumn<{
+        name: import("drizzle-orm/pg-core").PgColumn<{
             name: "name";
             tableName: "mfas";
             dataType: "string";
@@ -188,7 +186,7 @@ declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        userId: drizzle_orm_pg_core.PgColumn<{
+        userId: import("drizzle-orm/pg-core").PgColumn<{
             name: "userId";
             tableName: "mfas";
             dataType: "string";
@@ -200,7 +198,7 @@ declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        type: drizzle_orm_pg_core.PgColumn<{
+        type: import("drizzle-orm/pg-core").PgColumn<{
             name: "type";
             tableName: "mfas";
             dataType: "string";
@@ -212,7 +210,7 @@ declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: ["TOTP", "HARDWARE"];
             baseColumn: never;
         }, {}, {}>;
-        secret: drizzle_orm_pg_core.PgColumn<{
+        secret: import("drizzle-orm/pg-core").PgColumn<{
             name: "secret";
             tableName: "mfas";
             dataType: "string";
@@ -224,7 +222,7 @@ declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        verifiedAt: drizzle_orm_pg_core.PgColumn<{
+        verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "verifiedAt";
             tableName: "mfas";
             dataType: "date";
@@ -239,12 +237,12 @@ declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-type AuthMFA = typeof authMFATable.$inferSelect;
-declare const authClientTable: drizzle_orm_pg_core.PgTableWithColumns<{
+export type AuthMFA = typeof authMFATable.$inferSelect;
+export declare const authClientTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "client_credentials";
     schema: "auth";
     columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
+        id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
             tableName: "client_credentials";
             dataType: "string";
@@ -256,7 +254,7 @@ declare const authClientTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        alias: drizzle_orm_pg_core.PgColumn<{
+        alias: import("drizzle-orm/pg-core").PgColumn<{
             name: "alias";
             tableName: "client_credentials";
             dataType: "string";
@@ -268,7 +266,7 @@ declare const authClientTable: drizzle_orm_pg_core.PgTableWithColumns<{
             enumValues: [string, ...string[]];
             baseColumn: never;
         }, {}, {}>;
-        secret: drizzle_orm_pg_core.PgColumn<{
+        secret: import("drizzle-orm/pg-core").PgColumn<{
             name: "secret";
             tableName: "client_credentials";
             dataType: "string";
@@ -283,6 +281,4 @@ declare const authClientTable: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-type AuthClient = typeof authClientTable.$inferSelect;
-
-export { type AuthClient, type AuthMFA, type AuthReset, type AuthSession, type AuthUser, type Scope, authClientTable, authMFATable, authResetTable, authSchema, authSessionTable, authUserTable, mfaType, scope };
+export type AuthClient = typeof authClientTable.$inferSelect;

package/dist/database/schema.js

@@ -0,0 +1,42 @@
+/* istanbul ignore file */
+import { integer, pgEnum, pgSchema, text, timestamp } from 'drizzle-orm/pg-core';
+const DEFAULT_ROLE = 10;
+export const mfaType = pgEnum('mfaType', ['TOTP', 'HARDWARE']);
+export const scope = pgEnum('scope', ['ANON', 'MFA', 'AUTHED']);
+export const authSchema = pgSchema('auth');
+export const authUserTable = authSchema.table('user_credentials', {
+    id: text('id').primaryKey(),
+    email: text('email').notNull().unique(),
+    password: text('password'),
+    role: integer('role').notNull().default(DEFAULT_ROLE),
+});
+export const authSessionTable = authSchema.table('sessions', {
+    id: text('id').primaryKey(),
+    userId: text('userId')
+        .notNull()
+        .references(() => authUserTable.id),
+    scope: scope('scope').notNull().default('ANON'),
+    expiresAt: timestamp('expiresAt').notNull(),
+});
+export const authResetTable = authSchema.table('resets', {
+    id: text('id').primaryKey(),
+    userId: text('userId')
+        .notNull()
+        .references(() => authUserTable.id),
+    expiresAt: timestamp('expiresAt').notNull(),
+});
+export const authMFATable = authSchema.table('mfas', {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    userId: text('userId')
+        .notNull()
+        .references(() => authUserTable.id),
+    type: mfaType('type').notNull().default('TOTP'),
+    secret: text('secret').notNull(),
+    verifiedAt: timestamp('verifiedAt'),
+});
+export const authClientTable = authSchema.table('client_credentials', {
+    id: text('id').primaryKey(),
+    alias: text('alias').notNull().unique(),
+    secret: text('secret').notNull().unique(),
+});

package/dist/forms/FormService.d.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,78 @@
+/* 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

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

@@ -0,0 +1,19 @@
+'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

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

package/dist/forms/ValidationError.js

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

package/dist/forms/ValidationService.d.ts

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,59 @@
+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/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FormService';
+export * from './ImageService';
+export * from './ValidationService';

package/dist/forms/index.js

@@ -0,0 +1,3 @@
+export * from './FormService';
+export * from './ImageService';
+export * from './ValidationService';

package/dist/forms/lang.d.ts

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