@sqrzro/auth 4.0.0-alpha.1 → 4.0.0-alpha.10

package/src/utility/get-complexity.ts

@@ -0,0 +1,14 @@
+import type { PasswordComplexityObject } from './interfaces';
+
+const DEFAULT_COMPLEXITY: PasswordComplexityObject = {
+    LENGTH: 8,
+    LOWERCASE: 1,
+    UPPERCASE: 1,
+    NUMBER: 1,
+};
+
+function getComplexity(complexity?: PasswordComplexityObject): PasswordComplexityObject {
+    return complexity ?? DEFAULT_COMPLEXITY;
+}
+
+export default getComplexity;

package/src/utility/interfaces.ts

@@ -0,0 +1,11 @@
+export enum PasswordComplexityKey {
+    LENGTH = 'LENGTH',
+    UPPERCASE = 'UPPERCASE',
+    LOWERCASE = 'LOWERCASE',
+    NUMBER = 'NUMBER',
+    SPECIAL = 'SPECIAL',
+}
+
+export type PasswordComplexityObject = Partial<Record<PasswordComplexityKey, number>>;
+
+export type PasswordComplexityResult = { status: boolean; value: string }[];

package/src/utility/lang.ts

@@ -0,0 +1,14 @@
+import { formatPlural } from '@sqrzro/utility';
+
+import { PasswordComplexityKey } from './interfaces';
+
+export const complexities: Record<PasswordComplexityKey, (value?: number) => string> = {
+    [PasswordComplexityKey.LENGTH]: (value) => `At least ${formatPlural('character', value)} long`,
+    [PasswordComplexityKey.UPPERCASE]: (value) =>
+        `Contain at least ${formatPlural('uppercase letter', value)}`,
+    [PasswordComplexityKey.LOWERCASE]: (value) =>
+        `Contain at least ${formatPlural('lowercase letter', value)}`,
+    [PasswordComplexityKey.NUMBER]: (value) => `Contain at least ${formatPlural('number', value)}`,
+    [PasswordComplexityKey.SPECIAL]: (value) =>
+        `Contain at least ${formatPlural('special character', value)}`,
+};

package/src/utility/validate-complexity.ts

@@ -0,0 +1,53 @@
+import { getEntries, getKeys } from '@sqrzro/utility';
+import { z } from 'zod';
+
+import createComplexitySchema from './create-complexity-schema';
+import { complexities } from './lang';
+
+import { PasswordComplexityKey } from './interfaces';
+import type { PasswordComplexityObject, PasswordComplexityResult } from './interfaces';
+
+function getDefaultComplexityResult(
+    complexity: PasswordComplexityObject
+): PasswordComplexityResult {
+    return getEntries(complexity).map(([key, value]) => ({
+        status: false,
+        value: complexities[key](value),
+    }));
+}
+
+function transformResult(
+    complexity: PasswordComplexityObject,
+    errors: PasswordComplexityKey[]
+): PasswordComplexityResult {
+    // If there are errors that don't match the complexity keys (for example, the initial state), return the default result
+
+    if (errors.find((error) => !getKeys(complexity).includes(error))) {
+        return getDefaultComplexityResult(complexity);
+    }
+
+    return getEntries(complexity).map(([key, value]) => ({
+        status: !errors.includes(key),
+        value: complexities[key](value),
+    }));
+}
+
+function validateComplexity(
+    complexity: PasswordComplexityObject,
+    password?: string
+): PasswordComplexityResult {
+    try {
+        createComplexitySchema(complexity).parse(password);
+        return transformResult(complexity, []);
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            return transformResult(
+                complexity,
+                error.issues.map((issue) => issue.message as PasswordComplexityKey)
+            );
+        }
+        return getDefaultComplexityResult(complexity);
+    }
+}
+
+export default validateComplexity;

package/src/handle-proxy.ts

@@ -1,23 +0,0 @@
-import { validateSession } from '@sqrzro/server/auth';
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-
-async function handleProxy(request: NextRequest): Promise<NextResponse> {
-    const pathname = request.nextUrl.pathname;
-    const validated = await validateSession(request.cookies);
-
-    if (validated) {
-        if (pathname.startsWith('/auth')) {
-            return NextResponse.redirect(new URL('/', request.url));
-        }
-        return NextResponse.next();
-    }
-
-    if (pathname.startsWith('/auth')) {
-        return NextResponse.next();
-    }
-
-    return NextResponse.redirect(new URL('/auth/login', request.url));
-}
-
-export default handleProxy;