@appconda/sdk 1.0.193 → 1.0.409

package/dist/actions/nextAuthHandler.js

@@ -0,0 +1,6 @@
+import NextAuth from "next-auth";
+import { authOptions } from "./authOptions";
+export const getHandler = () => {
+    return NextAuth(authOptions());
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV4dEF1dGhIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FjdGlvbnMvbmV4dEF1dGhIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUNqQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTVDLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxHQUFHLEVBQUU7SUFDM0IsT0FBTyxRQUFRLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQTtBQUNsQyxDQUFDLENBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJcblxuaW1wb3J0IE5leHRBdXRoIGZyb20gXCJuZXh0LWF1dGhcIjtcbmltcG9ydCB7IGF1dGhPcHRpb25zIH0gZnJvbSBcIi4vYXV0aE9wdGlvbnNcIjtcblxuZXhwb3J0IGNvbnN0IGdldEhhbmRsZXIgPSAoKSA9PiB7XG4gICAgcmV0dXJuIE5leHRBdXRoKGF1dGhPcHRpb25zKCkpXG59IDtcblxuIl19

package/dist/client.d.ts

@@ -0,0 +1,141 @@
+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;
+};
+declare class AppcondaException extends Error {
+    code: number;
+    response: string;
+    type: string;
+    constructor(message: string, code?: number, type?: string, response?: string);
+}
+declare class Client {
+    static CHUNK_SIZE: number;
+    config: {
+        endpoint: string;
+        selfSigned: boolean;
+        project: string;
+        mode: string;
+        key: string;
+        jwt: string;
+        locale: string;
+        session: string;
+        forwardeduseragent: string;
+    };
+    headers: Headers;
+    /**
+     * Set Endpoint
+     *
+     * Your project endpoint
+     *
+     * @param {string} endpoint
+     *
+     * @returns {this}
+     */
+    setEndpoint(endpoint: string): this;
+    /**
+     * Set self-signed
+     *
+     * @param {boolean} selfSigned
+     *
+     * @returns {this}
+     */
+    setSelfSigned(selfSigned: boolean): this;
+    /**
+     * Add header
+     *
+     * @param {string} header
+     * @param {string} value
+     *
+     * @returns {this}
+     */
+    addHeader(header: string, value: string): this;
+    /**
+     * Set Project
+     *
+     * Your project ID
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setProject(value: string): this;
+    /**
+   * Set Mode
+   *
+   * @param value string
+   *
+   * @return {this}
+   */
+    setMode(value: string): this;
+    /**
+     * Set Key
+     *
+     * Your secret API key
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setKey(value: string): this;
+    /**
+     * Set JWT
+     *
+     * Your secret JSON Web Token
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setJWT(value: string): this;
+    /**
+     * Set Locale
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setLocale(value: string): this;
+    /**
+     * Set Session
+     *
+     * The user session to authenticate with
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setSession(value: string): this;
+    /**
+     * Set ForwardedUserAgent
+     *
+     * The user agent string of the client that made the request
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setForwardedUserAgent(value: string): this;
+    setFallbackCookies(value: string): this;
+    prepareRequest(method: string, url: URL, headers?: Headers, params?: Payload): {
+        uri: string;
+        options: RequestInit;
+    };
+    chunkedUpload(method: string, url: URL, headers: Headers | undefined, originalPayload: Payload | undefined, onProgress: (progress: UploadProgress) => void): Promise<any>;
+    redirect(method: string, url: URL, headers?: Headers, params?: Payload): Promise<string>;
+    call(method: string, url: URL, headers?: Headers, params?: Payload, responseType?: string): Promise<any>;
+    static flatten(data: Payload, prefix?: string): Payload;
+}
+export { Client, AppcondaException };
+export { Query } from './query';
+export type { Models, Payload, UploadProgress };
+export type { QueryTypes, QueryTypesList } from './query';

package/dist/client.js

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

package/dist/decorators/Cache.d.ts

@@ -0,0 +1 @@
+export declare function Cache(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/decorators/Cache.js

@@ -0,0 +1,79 @@
+import { Services } from "../lib/Services";
+function stableStringify(obj) {
+    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) {
+    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, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const className = target.constructor.name.toLowerCase();
+            // Metod adı
+            const methodName = propertyKey.toLowerCase();
+            const cacheKeys = [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);
+    }
+} */ 
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/CacheKey.d.ts

@@ -0,0 +1 @@
+export declare function CacheKey(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;

package/dist/decorators/CacheKey.js

@@ -0,0 +1,9 @@
+export function CacheKey() {
+    return function (target, propertyKey, parameterIndex) {
+        if (!target.__cacheKeys) {
+            target.__cacheKeys = [];
+        }
+        target.__cacheKeys.push({ propertyKey, parameterIndex });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVLZXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVjb3JhdG9ycy9DYWNoZUtleS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxNQUFNLFVBQVUsUUFBUTtJQUNwQixPQUFPLFVBQVUsTUFBVyxFQUFFLFdBQTRCLEVBQUUsY0FBc0I7UUFDOUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUN0QixNQUFNLENBQUMsV0FBVyxHQUFHLEVBQUUsQ0FBQztRQUM1QixDQUFDO1FBQ0QsTUFBTSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsRUFBRSxXQUFXLEVBQUUsY0FBYyxFQUFFLENBQUMsQ0FBQztJQUM3RCxDQUFDLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiXG5leHBvcnQgZnVuY3Rpb24gQ2FjaGVLZXkoKSB7XG4gICAgcmV0dXJuIGZ1bmN0aW9uICh0YXJnZXQ6IGFueSwgcHJvcGVydHlLZXk6IHN0cmluZyB8IHN5bWJvbCwgcGFyYW1ldGVySW5kZXg6IG51bWJlcik6IHZvaWQge1xuICAgICAgICBpZiAoIXRhcmdldC5fX2NhY2hlS2V5cykge1xuICAgICAgICAgICAgdGFyZ2V0Ll9fY2FjaGVLZXlzID0gW107XG4gICAgICAgIH1cbiAgICAgICAgdGFyZ2V0Ll9fY2FjaGVLZXlzLnB1c2goeyBwcm9wZXJ0eUtleSwgcGFyYW1ldGVySW5kZXggfSk7XG4gICAgfTtcbn0iXX0=

package/dist/decorators/Invalidate.d.ts

@@ -0,0 +1 @@
+export declare function Invalidate(keys: string | string[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;