@appconda/nextjs 1.0.18 → 1.0.19

package/dist/client.js

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

package/dist/decorators/Cache.js

@@ -0,0 +1,78 @@
+import { Services } from "@/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);
+    }
+} */ 

package/dist/decorators/CacheKey.js

@@ -0,0 +1,8 @@
+export function CacheKey() {
+    return function (target, propertyKey, parameterIndex) {
+        if (!target.__cacheKeys) {
+            target.__cacheKeys = [];
+        }
+        target.__cacheKeys.push({ propertyKey, parameterIndex });
+    };
+}

package/dist/decorators/Invalidate.js

@@ -0,0 +1,46 @@
+import { Services } from "@/Services";
+export function Invalidate(keys) {
+    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 cacheKey = ['admin', className];
+            // 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)
+            for (let key of keys) {
+                Services.Cache.purge([...cacheKey, key]);
+                Services.Cache.delWithStart([...cacheKey, key]);
+            }
+            console.log('------------------------------Cache deleted.');
+            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);
+    }
+} */ 

package/dist/enums/api-service.js

@@ -0,0 +1,14 @@
+export var ApiService;
+(function (ApiService) {
+    ApiService["Account"] = "account";
+    ApiService["Avatars"] = "avatars";
+    ApiService["Databases"] = "databases";
+    ApiService["Locale"] = "locale";
+    ApiService["Health"] = "health";
+    ApiService["Storage"] = "storage";
+    ApiService["Teams"] = "teams";
+    ApiService["Users"] = "users";
+    ApiService["Functions"] = "functions";
+    ApiService["Graphql"] = "graphql";
+    ApiService["Messaging"] = "messaging";
+})(ApiService || (ApiService = {}));

package/dist/enums/api.js

@@ -0,0 +1,6 @@
+export var Api;
+(function (Api) {
+    Api["Rest"] = "rest";
+    Api["Graphql"] = "graphql";
+    Api["Realtime"] = "realtime";
+})(Api || (Api = {}));

package/dist/enums/auth-method.js

@@ -0,0 +1,10 @@
+export var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod["Emailpassword"] = "email-password";
+    AuthMethod["Magicurl"] = "magic-url";
+    AuthMethod["Emailotp"] = "email-otp";
+    AuthMethod["Anonymous"] = "anonymous";
+    AuthMethod["Invites"] = "invites";
+    AuthMethod["Jwt"] = "jwt";
+    AuthMethod["Phone"] = "phone";
+})(AuthMethod || (AuthMethod = {}));

package/dist/enums/authentication-factor.js

@@ -0,0 +1,7 @@
+export var AuthenticationFactor;
+(function (AuthenticationFactor) {
+    AuthenticationFactor["Email"] = "email";
+    AuthenticationFactor["Phone"] = "phone";
+    AuthenticationFactor["Totp"] = "totp";
+    AuthenticationFactor["Recoverycode"] = "recoverycode";
+})(AuthenticationFactor || (AuthenticationFactor = {}));

package/dist/enums/authenticator-type.js

@@ -0,0 +1,4 @@
+export var AuthenticatorType;
+(function (AuthenticatorType) {
+    AuthenticatorType["Totp"] = "totp";
+})(AuthenticatorType || (AuthenticatorType = {}));

package/dist/enums/browser.js

@@ -0,0 +1,17 @@
+export var Browser;
+(function (Browser) {
+    Browser["AvantBrowser"] = "aa";
+    Browser["AndroidWebViewBeta"] = "an";
+    Browser["GoogleChrome"] = "ch";
+    Browser["GoogleChromeIOS"] = "ci";
+    Browser["GoogleChromeMobile"] = "cm";
+    Browser["Chromium"] = "cr";
+    Browser["MozillaFirefox"] = "ff";
+    Browser["Safari"] = "sf";
+    Browser["MobileSafari"] = "mf";
+    Browser["MicrosoftEdge"] = "ps";
+    Browser["MicrosoftEdgeIOS"] = "oi";
+    Browser["OperaMini"] = "om";
+    Browser["Opera"] = "op";
+    Browser["OperaNext"] = "on";
+})(Browser || (Browser = {}));

package/dist/enums/compression.js

@@ -0,0 +1,6 @@
+export var Compression;
+(function (Compression) {
+    Compression["None"] = "none";
+    Compression["Gzip"] = "gzip";
+    Compression["Zstd"] = "zstd";
+})(Compression || (Compression = {}));

package/dist/enums/credit-card.js

@@ -0,0 +1,19 @@
+export var CreditCard;
+(function (CreditCard) {
+    CreditCard["AmericanExpress"] = "amex";
+    CreditCard["Argencard"] = "argencard";
+    CreditCard["Cabal"] = "cabal";
+    CreditCard["Cencosud"] = "cencosud";
+    CreditCard["DinersClub"] = "diners";
+    CreditCard["Discover"] = "discover";
+    CreditCard["Elo"] = "elo";
+    CreditCard["Hipercard"] = "hipercard";
+    CreditCard["JCB"] = "jcb";
+    CreditCard["Mastercard"] = "mastercard";
+    CreditCard["Naranja"] = "naranja";
+    CreditCard["TarjetaShopping"] = "targeta-shopping";
+    CreditCard["UnionChinaPay"] = "union-china-pay";
+    CreditCard["Visa"] = "visa";
+    CreditCard["MIR"] = "mir";
+    CreditCard["Maestro"] = "maestro";
+})(CreditCard || (CreditCard = {}));

package/dist/enums/database-usage-range.js

@@ -0,0 +1,6 @@
+export var DatabaseUsageRange;
+(function (DatabaseUsageRange) {
+    DatabaseUsageRange["TwentyFourHours"] = "24h";
+    DatabaseUsageRange["ThirtyDays"] = "30d";
+    DatabaseUsageRange["NinetyDays"] = "90d";
+})(DatabaseUsageRange || (DatabaseUsageRange = {}));