@appconda/nextjs 1.0.12

package/src/Cache/Adapters/Sharding.ts

@@ -0,0 +1,87 @@
+import { Adapter } from "../Adapter";
+
+    export class Sharding implements Adapter {
+        protected adapters: Adapter[];
+        protected count: number = 0;
+
+        constructor(adapters: Adapter[]) {
+            if (adapters.length === 0) {
+                throw new Error('No adapters provided');
+            }
+
+            this.count = adapters.length;
+            this.adapters = adapters;
+        }
+        delWithStart(pattern: string): Promise<number> {
+            throw new Error("Method not implemented.");
+        }
+
+      async  load(key: string, ttl: number, hash: string = ''): Promise<any> {
+            const adapter =  this.getAdapter(key);
+            return await adapter.load(key, ttl, hash);
+        }
+
+        async save(key: string, data: any, hash: string = ''): Promise<boolean | string | any[]> {
+            return this.getAdapter(key).save(key, data, hash);
+        }
+
+        async list(key: string): Promise<string[]> {
+            return this.getAdapter(key).list(key);
+        }
+
+        async purge(key: string, hash: string = ''): Promise<boolean> {
+            return this.getAdapter(key).purge(key, hash);
+        }
+
+        async flush(): Promise<boolean> {
+            let result = true;
+            for (const adapter of this.adapters) {
+                result = await adapter.flush() ? result : false;
+            }
+            return result;
+        }
+
+        async ping(): Promise<boolean> {
+            for (const adapter of this.adapters) {
+                if (!adapter.ping()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        async getSize(): Promise<number> {
+            let size = 0;
+            for (const adapter of this.adapters) {
+                size += await adapter.getSize();
+            }
+            return size;
+        }
+
+        protected getAdapter(key: string): Adapter {
+            const hash = this.crc32(key);
+            const index = hash % this.count;
+            return this.adapters[index];
+        }
+
+        private crc32(str: string): number {
+            let crc = 0 ^ (-1);
+            for (let i = 0; i < str.length; i++) {
+                crc = (crc >>> 8) ^ this.crc32Table[(crc ^ str.charCodeAt(i)) & 0xff];
+            }
+            return (crc ^ (-1)) >>> 0;
+        }
+
+        private crc32Table = (() => {
+            let c: number;
+            const table: number[] = [];
+            for (let n = 0; n < 256; n++) {
+                c = n;
+                for (let k = 0; k < 8; k++) {
+                    c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
+                }
+                table[n] = c;
+            }
+            return table;
+        })();
+    }

package/src/Cache/Cache.ts

@@ -0,0 +1,75 @@
+import { Adapter } from "./Adapter";
+
+
+export class Cache {
+    private adapter: Adapter;
+    public static caseSensitive: boolean = false;
+
+    constructor(adapter: Adapter) {
+        this.adapter = adapter;
+    }
+
+    private constructKey(key: any): string {
+        if (Array.isArray(key)) {
+            key = key.join(':');
+        }
+
+        return key;
+    }
+
+    public static setCaseSensitivity(value: boolean): boolean {
+        return this.caseSensitive = value;
+    }
+
+    public async load(key: string | string[], ttl: number = 60 * 60 * 24, hash: string = ''): Promise<any> {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+
+        return await this.adapter.load(key, ttl, hash);
+    }
+
+    public async save(key: string | string[], data: any, hash: string = ''): Promise<boolean | string | any[]> {
+
+        key = this.constructKey(key);
+
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+
+        return this.adapter.save(key, data, hash);
+    }
+
+    public async list(key: string | string[]): Promise<string[]> {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+
+        return this.adapter.list(key);
+    }
+
+    public async purge(key: string | string[], hash: string = ''): Promise<boolean> {
+
+        key = this.constructKey(key);
+
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+
+        return this.adapter.purge(key, hash);
+    }
+
+    public async flush(): Promise<boolean> {
+        return this.adapter.flush();
+    }
+
+    public async ping(): Promise<boolean> {
+        return this.adapter.ping();
+    }
+
+    public async getSize(): Promise<number> {
+        return this.adapter.getSize();
+    }
+
+    public async delWithStart(keys: string | string[]): Promise<number> {
+        const pattern = this.constructKey(keys);
+        return this.adapter.delWithStart(pattern);
+    }
+}

package/src/Cache/index.ts

@@ -0,0 +1,5 @@
+export * from './Cache';
+export * from './Adapters/None';
+export * from './Adapters/Redis';
+export * from './Adapters/Sharding';
+export * from './Adapters/Memory';

package/src/Services.ts

@@ -0,0 +1,41 @@
+import { Registry } from "@/lib/Registry";
+import { createClient } from 'redis';
+import { Redis } from "./Cache/Adapters/Redis";
+import { Cache } from "./Cache";
+
+
+export const registry = new Registry();
+
+registry.set('cache', () => {
+    const client = createClient({
+        socket: {
+            host: process.env._APP_REDIS_HOST ?? 'localhost',
+            port: Number.parseInt(process.env._APP_REDIS_PORT ?? '6379'),
+
+        },
+        password: undefined,
+    });
+
+    // Bağlantı hatalarını ele al
+    client.on('error', (err) => {
+
+        console.error('Redis Client Error', err);
+    });
+
+    // Connect to Redis
+    client.connect();
+
+    const redisAdapter = new Redis(client as any);
+
+    const cacheProvider = new Cache(redisAdapter);
+
+    return cacheProvider;
+
+})
+
+export class Services {
+    public static get Cache(): Cache {
+        return registry.get('cache');
+    }
+   
+}

package/src/client.ts

@@ -0,0 +1,397 @@
+import { fetch, FormData, File } from 'node-fetch-native-with-agent';
+import { createAgent } from 'node-fetch-native-with-agent/agent';
+import { Models } from './models';
+
+type Payload = {
+    [key: string]: any;
+}
+
+type UploadProgress = {
+    $id: string;
+    progress: number;
+    sizeUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+}
+
+type Headers = {
+    [key: string]: string;
+}
+
+class AppcondaException extends Error {
+    code: number;
+    response: string;
+    type: string;
+    constructor(message: string, code: number = 0, type: string = '', response: string = '') {
+        super(message);
+        this.name = 'AppcondaException';
+        this.message = message;
+        this.code = code;
+        this.type = type;
+        this.response = response;
+    }
+}
+
+function getUserAgent() {
+    let ua = 'AppcondaNodeJSSDK/14.1.0';
+
+    // `process` is a global in Node.js, but not fully available in all runtimes.
+    const platform: string[] = [];
+    if (typeof process !== 'undefined') {
+        if (typeof process.platform === 'string') platform.push(process.platform);
+        if (typeof process.arch === 'string') platform.push(process.arch);
+    }
+    if (platform.length > 0) {
+        ua += ` (${platform.join('; ')})`;
+    }
+
+    // `navigator.userAgent` is available in Node.js 21 and later.
+    // It's also part of the WinterCG spec, so many edge runtimes provide it.
+    // https://common-min-api.proposal.wintercg.org/#requirements-for-navigatoruseragent
+    // @ts-ignore
+    if (typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string') {
+        // @ts-ignore
+        ua += ` ${navigator.userAgent}`;
+
+        // @ts-ignore
+    } else if (typeof globalThis.EdgeRuntime === 'string') {
+        ua += ` EdgeRuntime`;
+
+        // Older Node.js versions don't have `navigator.userAgent`, so we have to use `process.version`.
+    } else if (typeof process !== 'undefined' && typeof process.version === 'string') {
+        ua += ` Node.js/${process.version}`;
+    }
+
+    return ua;
+}
+
+class Client {
+    static CHUNK_SIZE = 1024 * 1024 * 5;
+
+    config = {
+        endpoint: 'https://cloud.appconda.io/v1',
+        selfSigned: false,
+        project: '',
+        mode: '',
+        key: '',
+        jwt: '',
+        locale: '',
+        session: '',
+        forwardeduseragent: '',
+    };
+    headers: Headers = {
+        'x-sdk-name': 'Node.js',
+        'x-sdk-platform': 'server',
+        'x-sdk-language': 'nodejs',
+        'x-sdk-version': '14.1.0',
+        'user-agent': getUserAgent(),
+        'X-Appconda-Response-Format': '1.6.0',
+    };
+
+    /**
+     * Set Endpoint
+     *
+     * Your project endpoint
+     *
+     * @param {string} endpoint
+     *
+     * @returns {this}
+     */
+    setEndpoint(endpoint: string): this {
+        this.config.endpoint = endpoint;
+
+        return this;
+    }
+
+    /**
+     * Set self-signed
+     *
+     * @param {boolean} selfSigned
+     *
+     * @returns {this}
+     */
+    setSelfSigned(selfSigned: boolean): this {
+        // @ts-ignore
+        if (typeof globalThis.EdgeRuntime !== 'undefined') {
+            console.warn('setSelfSigned is not supported in edge runtimes.');
+        }
+
+        this.config.selfSigned = selfSigned;
+
+        return this;
+    }
+
+    /**
+     * Add header
+     *
+     * @param {string} header
+     * @param {string} value
+     *
+     * @returns {this}
+     */
+    addHeader(header: string, value: string): this {
+        this.headers[header.toLowerCase()] = value;
+
+        return this;
+    }
+
+    /**
+     * Set Project
+     *
+     * Your project ID
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setProject(value: string): this {
+        this.headers['X-Appconda-Project'] = value;
+        this.config.project = value;
+        return this;
+    }
+
+      /**
+     * Set Mode
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+      setMode(value: string): this {
+        this.headers['X-Appconda-Mode'] = value;
+        this.config.mode = value;
+        return this;
+    }
+
+    /**
+     * Set Key
+     *
+     * Your secret API key
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setKey(value: string): this {
+        this.headers['X-Appconda-Key'] = value;
+        this.config.key = value;
+        return this;
+    }
+    /**
+     * Set JWT
+     *
+     * Your secret JSON Web Token
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setJWT(value: string): this {
+        this.headers['X-Appconda-JWT'] = value;
+        this.config.jwt = value;
+        return this;
+    }
+    /**
+     * Set Locale
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setLocale(value: string): this {
+        this.headers['X-Appconda-Locale'] = value;
+        this.config.locale = value;
+        return this;
+    }
+    /**
+     * Set Session
+     *
+     * The user session to authenticate with
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setSession(value: string): this {
+        this.headers['X-Appconda-Session'] = value;
+        this.config.session = value;
+        return this;
+    }
+    /**
+     * Set ForwardedUserAgent
+     *
+     * The user agent string of the client that made the request
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setForwardedUserAgent(value: string): this {
+        this.headers['X-Forwarded-User-Agent'] = value;
+        this.config.forwardeduseragent = value;
+        return this;
+    }
+
+    setFallbackCookies(value: string): this {
+        this.headers['X-Fallback-Cookies'] = value;
+        //this.config.forwardeduseragent = value;
+        return this;
+    }
+
+    prepareRequest(method: string, url: URL, headers: Headers = {}, params: Payload = {}): { uri: string, options: RequestInit } {
+        method = method.toUpperCase();
+
+        headers = Object.assign({}, this.headers, headers);
+
+        let options: RequestInit = {
+            method,
+            headers,
+            ...createAgent(this.config.endpoint, { rejectUnauthorized: !this.config.selfSigned }),
+        };
+
+        if (method === 'GET') {
+            for (const [key, value] of Object.entries(Client.flatten(params))) {
+                url.searchParams.append(key, value);
+            }
+        } else {
+            switch (headers['content-type']) {
+                case 'application/json':
+                    options.body = JSON.stringify(params);
+                    break;
+
+                case 'multipart/form-data':
+                    const formData = new FormData();
+
+                    for (const [key, value] of Object.entries(params)) {
+                        if (value instanceof File) {
+                            formData.append(key, value, value.name);
+                        } else if (Array.isArray(value)) {
+                            for (const nestedValue of value) {
+                                formData.append(`${key}[]`, nestedValue);
+                            }
+                        } else {
+                            formData.append(key, value);
+                        }
+                    }
+
+                    options.body = formData;
+                    delete headers['content-type'];
+                    break;
+            }
+        }
+
+        return { uri: url.toString(), options };
+    }
+
+    async chunkedUpload(method: string, url: URL, headers: Headers = {}, originalPayload: Payload = {}, onProgress: (progress: UploadProgress) => void) {
+        const file: any = Object.values(originalPayload).find((value) => value instanceof File);
+
+        if (file.size <= Client.CHUNK_SIZE) {
+            return await this.call(method, url, headers, originalPayload);
+        }
+
+        let start = 0;
+        let response = null;
+
+        while (start < file.size) {
+            let end = start + Client.CHUNK_SIZE; // Prepare end for the next chunk
+            if (end >= file.size) {
+                end = file.size; // Adjust for the last chunk to include the last byte
+            }
+
+            headers['content-range'] = `bytes ${start}-${end - 1}/${file.size}`;
+            const chunk = file.slice(start, end);
+
+            let payload = { ...originalPayload, file: new File([chunk], file.name) };
+
+            response = await this.call(method, url, headers, payload);
+
+            if (onProgress && typeof onProgress === 'function') {
+                onProgress({
+                    $id: response.$id,
+                    progress: Math.round((end / file.size) * 100),
+                    sizeUploaded: end,
+                    chunksTotal: Math.ceil(file.size / Client.CHUNK_SIZE),
+                    chunksUploaded: Math.ceil(end / Client.CHUNK_SIZE)
+                });
+            }
+
+            if (response && response.$id) {
+                headers['x-appconda-id'] = response.$id;
+            }
+
+            start = end;
+        }
+
+        return response;
+    }
+
+    async redirect(method: string, url: URL, headers: Headers = {}, params: Payload = {}): Promise<string> {
+        const { uri, options } = this.prepareRequest(method, url, headers, params);
+
+        const response = await fetch(uri, {
+            ...options,
+            redirect: 'manual'
+        });
+
+        if (response.status !== 301 && response.status !== 302) {
+            throw new AppcondaException('Invalid redirect', response.status);
+        }
+
+        return response.headers.get('location') || '';
+    }
+
+    async call(method: string, url: URL, headers: Headers = {}, params: Payload = {}, responseType = 'json'): Promise<any> {
+        const { uri, options } = this.prepareRequest(method, url, headers, params);
+
+        let data: any = null;
+
+        try {
+            const response = await fetch(uri, options);
+
+            const warnings = response.headers.get('x-appconda-warning');
+            if (warnings) {
+                warnings.split(';').forEach((warning: string) => console.warn('Warning: ' + warning));
+            }
+
+            if (response.headers.get('content-type')?.includes('application/json')) {
+                data = await response.json();
+            } else if (responseType === 'arrayBuffer') {
+                data = await response.arrayBuffer();
+            } else {
+                data = {
+                    message: await response.text()
+                };
+            }
+
+            if (400 <= response.status) {
+                throw new AppcondaException(data?.message, response.status, data?.type, data);
+            }
+
+            return data;
+        } catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
+
+    static flatten(data: Payload, prefix = ''): Payload {
+        let output: Payload = {};
+
+        for (const [key, value] of Object.entries(data)) {
+            let finalKey = prefix ? prefix + '[' + key + ']' : key;
+            if (Array.isArray(value)) {
+                output = { ...output, ...Client.flatten(value, finalKey) };
+            } else {
+                output[finalKey] = value;
+            }
+        }
+
+        return output;
+    }
+}
+
+export { Client, AppcondaException };
+export { Query } from './query';
+export type { Models, Payload, UploadProgress };
+export type { QueryTypes, QueryTypesList } from './query';

package/src/decorators/Cache.ts

@@ -0,0 +1,102 @@
+import { Services } from "@/Services";
+
+function stableStringify(obj: any): string {
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      return `{${Object.keys(obj).sort().map(key => `"${key}":${stableStringify(obj[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(obj);
+  }
+  
+  function generateCacheKey(...args: any[]): string {
+    return stableStringify(args);
+  }
+  
+ 
+ // console.log(generateCacheKey("user", 123, true, { role: "admin", permissions: ["read", "write"] }));
+ // console.log(generateCacheKey("user", 123, true, { permissions: ["read", "write"], role: "admin" }));
+
+
+  
+export function Cache(/* cacheKey?: string | string[] */) {
+    return function (
+        target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+        const originalMethod = descriptor.value;
+
+        descriptor.value = async function (...args: any[]) {
+
+            const className = target.constructor.name.toLowerCase();
+
+            // Metod adı
+            const methodName = propertyKey.toLowerCase();
+
+            const cacheKeys: any[] = [target.__cacheKeys || []].reverse();
+            console.log("Defined cache keys:", cacheKeys);
+
+            const cacheKey = ['admin', className, propertyKey];
+
+            if (cacheKeys.length > 0) {
+                for (let i = 0; i < cacheKeys.length; i++) {
+                    const keyIndex = cacheKeys[i]['parameterIndex'];
+                    if (args != null && args[keyIndex] != null) {
+                        const key = args[keyIndex].toString();
+                        cacheKey.push(key);
+                    }
+                }
+            } else if (args.length > 0) { //cacheKey belirtilmemisse tum parametreleri kullan
+                for (let i = 0; i < args.length; i++) {
+                    const key = args[i].toString();
+                    cacheKey.push(key);
+                }
+            }
+
+            // Cache key'i dizeye dönüştür
+            // const key = Array.isArray(cacheKey) ? cacheKey.join(':') : cacheKey;
+
+            // Cache'ten veri al
+            let cachedData = await Services.Cache.load(cacheKey);
+
+            if (cachedData != null) {
+                return cachedData; // Cache'teki veriyi döndür
+            }
+
+            // Orijinal metodu çağır ve dönen değeri cache'e kaydet
+            const result = await originalMethod.apply(this, args);
+
+            // Cache'e kaydet (asenkron yapılır, beklenmez)
+            Services.Cache.save(cacheKey, result);
+            console.log('------------------------------Cache executed..')
+            return result;
+        };
+
+        return descriptor;
+    };
+}
+
+
+/* const cacheKeys: any[] = target.__cacheKeys || [];
+console.log("Defined cache keys:", [...cacheKeys].reverse());
+
+const className = target.constructor.name.toLowerCase();
+
+// Metod adı
+const methodName = propertyKey.toLowerCase();
+
+debugger
+const cacheKey = ['admin', className, propertyKey];
+if (cacheKey.length > 0) {
+    for (let i = 0; i < cacheKeys.length; i++) {
+        const keyIndex = cacheKeys[i]['parameterIndex'];
+        if (args != null && args[keyIndex] != null) {
+            const key = args[keyIndex].toString();
+            cacheKey.push(key);
+        }
+    }
+} else if (args.length > 0) { //cacheKey belirtilmemisse tum parametreleri kullan
+    for (let i = 0; i < args.length; i++) {
+        const key = args[i].toString();
+        cacheKey.push(key);
+    }
+} */