@epsbv/oauth-sdk 1.0.1

package/src/tenant/types.ts

@@ -0,0 +1,57 @@
+import { TcpNetConnectOpts } from "net"
+import { Language, Status } from "../types"
+
+// export enum TenantType {
+//     Admin = "admin",
+//     Distributor = "distributor",
+//     Builder = "builder"
+// }
+
+export enum TenantRole {
+    Guest = "guest",
+    Member = "member",
+    Admin = "admin",
+    Owner = "owner",
+}
+
+export interface TenantUser {
+    id: string,
+    uid: string,
+    email: string,
+    role: TenantRole,
+    avatar: string | undefined
+    first_name: string,
+    last_name: string,
+    language: Language
+    created_at: Date,
+    updated_at: Date,
+}
+
+export interface Tenant {
+    id: string
+    name: string
+    // type: TenantType
+    email: string
+    avatar: string | undefined
+    status: Status
+    parent: string,
+    language: Language,
+    created_at: Date,
+    updated_at: Date,
+}
+
+export interface Client {
+    id: string,
+    name: string
+    status: Status,
+    secret: string,
+    type: ClientType,
+    created_at: Date,
+    updated_at: Date,
+    redirect_uri: string
+}
+
+export enum ClientType {
+    Web = "web",
+    Public = "public"
+}

package/src/types.ts

@@ -0,0 +1,17 @@
+export interface ClientOptions {
+    token: string,
+    baseUrl: string
+}
+
+export enum Language {
+    NL = "NL",
+    DE = "DE",
+    FR = "FR",
+    EN = "EN"
+}
+
+export enum Status{
+    Pending = "pending",
+    Rejected = "rejected",
+    Accepted = "accepted",
+}

package/src/utils/fetch.ts

@@ -0,0 +1,161 @@
+export type FetchMethod = "GET" | "POST" | "DELETE" | "PUT" | 'PATCH';
+
+export interface FetchOptions {
+    body?: any,
+    headers?: HeadersInit
+}
+
+export async function fetchJson<T>(url: string, method: FetchMethod, options: FetchOptions) {
+    options.headers = new Headers(options.headers)
+
+    if (method != 'GET' && options.body != undefined) {
+        options.body = JSON.stringify(options.body);
+        options.headers.append('Content-Type', 'application/json');
+    }
+
+    try {
+        // Make the fetch request
+        const response = await fetch(url, {
+            method,
+            headers: options.headers,
+            body: options.body
+        });
+
+        const responseText = await response.text()
+
+        // Attempt to parse JSON response
+        try {
+            return JSON.parse(responseText) as T;
+        }
+        catch (_) {
+            throw new Error(responseText)
+        }
+    }
+    catch ({ message }: any) {
+        throw new Error(message)
+    }
+}
+
+export async function fetchUrlEncoded<T>(endpoint: string, method: FetchMethod, options: FetchOptions) {
+    let headers = new Headers(options.headers)
+    let body: string | undefined;
+
+    if (options.body != undefined) {
+        headers.append('Content-Type', 'application/x-www-form-urlencoded');
+        body = new URLSearchParams(options.body).toString()
+    }
+
+    try {
+        // Make the fetch request
+        const getBody = method == 'GET' && body != undefined;
+        const url = getBody ? `${endpoint}?${body}` : endpoint;
+
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: getBody ? null : body
+        });
+
+        const responseText = await response.text()
+
+        // Attempt to parse JSON response
+        try {
+            return JSON.parse(responseText) as T;
+        }
+        catch (_) {
+            throw new Error(responseText)
+        }
+    }
+    catch ({ message }: any) {
+        throw new Error(message)
+    }
+}
+
+export async function fetchMultipart<T>(endpoint: string, method: FetchMethod, options: FetchOptions) {
+    let formData = new FormData();
+
+    // Helper function to recursively append to FormData
+    const appendData = (data: any, parentKey?: string) => {
+        if (data === null || data === undefined) {
+            return;
+        }
+
+        // If it's a File or Blob, append directly
+        if (data instanceof File || data instanceof Blob) {
+            formData.append(parentKey!, data);
+            return;
+        }
+
+        // If it's an array
+        if (Array.isArray(data)) {
+            data.forEach((item, index) => {
+                const key = parentKey ? `${parentKey}[${index}]` : `[${index}]`;
+
+                if (item instanceof File || item instanceof Blob) {
+                    formData.append(key, item);
+                } else if (typeof item === 'object' && item !== null) {
+                    appendData(item, key);
+                } else {
+                    formData.append(key, String(item));
+                }
+            });
+            return;
+        }
+
+        // If it's an object
+        if (typeof data === 'object') {
+            Object.entries(data).forEach(([key, value]) => {
+                const fullKey = parentKey ? `${parentKey}[${key}]` : key;
+
+                if (value instanceof File || value instanceof Blob) {
+                    formData.append(fullKey, value);
+                } else if (value instanceof Date) {
+                    formData.append(fullKey, value.toISOString());
+                } else if (typeof value === 'object' && value !== null) {
+                    appendData(value, fullKey);
+                } else if (value !== undefined && value !== null) {
+                    formData.append(fullKey, String(value));
+                }
+            });
+            return;
+        }
+
+        // For primitive values
+        if (parentKey) {
+            formData.append(parentKey, String(data));
+        }
+    }
+
+    // Convert body to FormData
+    if (options.body) {
+        appendData(options.body);
+    }
+
+    console.log(formData);
+    
+    try {
+        // Don't set Content-Type header - browser will set it with boundary
+        const headers = new Headers(options.headers);
+        headers.delete('Content-Type');
+        
+        const response = await fetch(endpoint, {
+            method,
+            headers,
+            body: formData
+        });
+
+        const responseText = await response.text()
+
+        // Attempt to parse JSON response
+        try {
+            return JSON.parse(responseText) as T;
+        }
+        catch (_) {
+            throw new Error(responseText)
+        }
+    }
+    catch ({ message }: any) {
+        throw new Error(message)
+    }
+
+}

package/src/utils/secret.ts

@@ -0,0 +1,28 @@
+import * as encoding from "@oslojs/encoding";
+import * as sha2 from "@oslojs/crypto/sha2";
+
+export function createS256CodeChallenge(codeVerifier: string): string {
+	const codeChallengeBytes = sha2.sha256(new TextEncoder().encode(codeVerifier));
+
+	return encoding.encodeBase64urlNoPadding(codeChallengeBytes);
+}
+
+export function generateCodeVerifier(): string {
+	const randomValues = new Uint8Array(32);
+
+	crypto.getRandomValues(randomValues);
+
+	return encoding.encodeBase64urlNoPadding(randomValues);
+}
+
+export function generateState(): string {
+	const randomValues = new Uint8Array(32);
+
+	crypto.getRandomValues(randomValues);
+
+	return encoding.encodeBase64urlNoPadding(randomValues);
+}
+
+export function encodeCredentials(key: string, secret: string): string {
+	return encoding.encodeBase64NoPadding(new TextEncoder().encode(`${key}:${secret}`))
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "incremental": true, /* Enable incremental compilation */
+    "target": "ES2022", /* Specify ECMAScript target version: */
+    "module": "ESNext", /* 'none', 'commonjs', 'amd', 'system', etc */
+    "declaration": true, /* Concatenate & emit output to single file.*/
+    "outDir": "build", /* Redirect output to the directory. */
+    "moduleResolution": "node",
+    "esModuleInterop": true, /* Enables intero between CommonJS and ES */
+    "skipLibCheck": true, /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently */
+  },
+  "include": [
+    "src"
+  ]
+}