@appconda/nextjs 1.0.12

package/docs/examples/users/update-phone-verification.md

@@ -0,0 +1,14 @@
+import { Client, Users } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const users = new Users(client);
+
+const result = await users.updatePhoneVerification(
+    '<USER_ID>', // userId
+    false // phoneVerification
+);
+
+console.log(result);

package/docs/examples/users/update-phone.md

@@ -0,0 +1,14 @@
+import { Client, Users } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const users = new Users(client);
+
+const result = await users.updatePhone(
+    '<USER_ID>', // userId
+    '+12065550100' // number
+);
+
+console.log(result);

package/docs/examples/users/update-prefs.md

@@ -0,0 +1,14 @@
+import { Client, Users } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const users = new Users(client);
+
+const result = await users.updatePrefs(
+    '<USER_ID>', // userId
+    {} // prefs
+);
+
+console.log(result);

package/docs/examples/users/update-status.md

@@ -0,0 +1,14 @@
+import { Client, Users } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const users = new Users(client);
+
+const result = await users.updateStatus(
+    '<USER_ID>', // userId
+    false // status
+);
+
+console.log(result);

package/docs/examples/users/update-target.md

@@ -0,0 +1,17 @@
+import { Client, Users } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const users = new Users(client);
+
+const result = await users.updateTarget(
+    '<USER_ID>', // userId
+    '<TARGET_ID>', // targetId
+    '<IDENTIFIER>', // identifier (optional)
+    '<PROVIDER_ID>', // providerId (optional)
+    '<NAME>' // name (optional)
+);
+
+console.log(result);

package/docs/examples/vcs/create-repository-detection.md

@@ -0,0 +1,15 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.createRepositoryDetection(
+    '<INSTALLATION_ID>', // installationId
+    '<PROVIDER_REPOSITORY_ID>', // providerRepositoryId
+    '<PROVIDER_ROOT_DIRECTORY>' // providerRootDirectory (optional)
+);
+
+console.log(result);

package/docs/examples/vcs/create-repository.md

@@ -0,0 +1,15 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.createRepository(
+    '<INSTALLATION_ID>', // installationId
+    '<NAME>', // name
+    false // private
+);
+
+console.log(result);

package/docs/examples/vcs/delete-installation.md

@@ -0,0 +1,13 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.deleteInstallation(
+    '<INSTALLATION_ID>' // installationId
+);
+
+console.log(result);

package/docs/examples/vcs/get-installation.md

@@ -0,0 +1,13 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.getInstallation(
+    '<INSTALLATION_ID>' // installationId
+);
+
+console.log(result);

package/docs/examples/vcs/get-repository-contents.md

@@ -0,0 +1,15 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.getRepositoryContents(
+    '<INSTALLATION_ID>', // installationId
+    '<PROVIDER_REPOSITORY_ID>', // providerRepositoryId
+    '<PROVIDER_ROOT_DIRECTORY>' // providerRootDirectory (optional)
+);
+
+console.log(result);

package/docs/examples/vcs/get-repository.md

@@ -0,0 +1,14 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.getRepository(
+    '<INSTALLATION_ID>', // installationId
+    '<PROVIDER_REPOSITORY_ID>' // providerRepositoryId
+);
+
+console.log(result);

package/docs/examples/vcs/list-installations.md

@@ -0,0 +1,14 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.listInstallations(
+    [], // queries (optional)
+    '<SEARCH>' // search (optional)
+);
+
+console.log(result);

package/docs/examples/vcs/list-repositories.md

@@ -0,0 +1,14 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.listRepositories(
+    '<INSTALLATION_ID>', // installationId
+    '<SEARCH>' // search (optional)
+);
+
+console.log(result);

package/docs/examples/vcs/list-repository-branches.md

@@ -0,0 +1,14 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.listRepositoryBranches(
+    '<INSTALLATION_ID>', // installationId
+    '<PROVIDER_REPOSITORY_ID>' // providerRepositoryId
+);
+
+console.log(result);

package/docs/examples/vcs/update-external-deployments.md

@@ -0,0 +1,15 @@
+import { Client, Vcs } from "@appconda.io/console";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appconda.io/v1') // Your API Endpoint
+    .setProject('<YOUR_PROJECT_ID>'); // Your project ID
+
+const vcs = new Vcs(client);
+
+const result = await vcs.updateExternalDeployments(
+    '<INSTALLATION_ID>', // installationId
+    '<REPOSITORY_ID>', // repositoryId
+    '<PROVIDER_PULL_REQUEST_ID>' // providerPullRequestId
+);
+
+console.log(result);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@appconda/nextjs",
+  "homepage": "https://appconda.io/support",
+  "description": "Appconda is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API",
+  "version": "1.0.12",
+  "license": "BSD-3-Clause",
+  "main": "dist/cjs/sdk.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/sdk.js",
+      "require": "./dist/cjs/sdk.js",
+      "types": "./types/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "dist/esm/sdk.js",
+  "types": "types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/appconda/sdk-for-console"
+  },
+  "scripts": {
+    "build": "npm run build:types && npm run build:libs",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir types",
+    "build:libs": "rollup -c"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.2",
+    "playwright": "1.15.0",
+    "rollup": "2.75.4",
+    "serve-handler": "6.1.0",
+    "tslib": "2.4.0",
+    "typescript": "^5.6.3"
+  },
+  "jsdelivr": "dist/iife/sdk.js",
+  "unpkg": "dist/iife/sdk.js",
+  "dependencies": {
+    "node-fetch-native-with-agent": "^1.7.2",
+    "redis": "^4.7.0",
+    "zod": "^3.24.2"
+  }
+}

package/publish.sh

@@ -0,0 +1,4 @@
+
+npm version patch -m "Upgrade to new version"
+npm run build
+npm publish --access public

package/rollup.config.js

@@ -0,0 +1,27 @@
+import pkg from "./package.json";
+import typescript from "@rollup/plugin-typescript";
+
+export default {
+    external: Object.keys(pkg.dependencies ?? {}),
+    input: "src/index.ts",
+    plugins: [typescript()],
+    output: [
+        {
+            format: "cjs",
+            file: pkg.main,
+            esModule: false,
+            sourcemap: true,
+        },
+        {
+            format: "es",
+            file: pkg.module,
+            sourcemap: true,
+        },
+        {
+            format: "iife",
+            file: pkg.jsdelivr,
+            name: "Appconda",
+            extend: true,
+        },
+    ],
+};

package/src/Cache/Adapter.ts

@@ -0,0 +1,11 @@
+
+export interface Adapter {
+    load(key: string, ttl: number, hash?: string): Promise<any>;
+    save(key: string, data: any, hash?: string): Promise<boolean | string | any[]>;
+    list(key: string): Promise<string[]>;
+    purge(key: string, hash?: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    ping(): Promise<boolean>;
+    getSize(): Promise<number>;
+     delWithStart(pattern: string): Promise<number>;
+}

package/src/Cache/Adapters/Filesystem.ts

@@ -0,0 +1,126 @@
+import { Adapter } from "../Adapter";
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+export class Filesystem implements Adapter {
+    protected path: string = '';
+
+    constructor(path: string) {
+        this.path = path;
+    }
+    delWithStart(pattern: string): Promise<number> {
+        throw new Error("Method not implemented.");
+    }
+
+    async load(key: string, ttl: number, hash: string = ''): Promise<any> {
+        const file = this.getPath(key);
+
+        if (fs.existsSync(file) && (fs.statSync(file).mtime.getTime() + ttl * 1000 > Date.now())) {
+            return fs.readFileSync(file, 'utf8');
+        }
+
+        return false;
+    }
+
+    async save(key: string, data: any, hash: string = ''): Promise<boolean | string | any[]> {
+        if (!data) {
+            return false;
+        }
+
+        const file = this.getPath(key);
+        const dir = path.dirname(file);
+
+        try {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            fs.writeFileSync(file, data, { flag: 'w' });
+            return data;
+        } catch (e: any) {
+            throw new Error(e.message);
+        }
+    }
+
+    async list(key: string): Promise<string[]> {
+        return [];
+    }
+
+    async purge(key: string, hash: string = ''): Promise<boolean> {
+        const file = this.getPath(key);
+
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+            return true;
+        }
+
+        return false;
+    }
+
+    async flush(): Promise<boolean> {
+        return this.deleteDirectory(this.path);
+    }
+
+    async ping(): Promise<boolean> {
+        return fs.existsSync(this.path) && fs.accessSync(this.path, fs.constants.W_OK | fs.constants.R_OK);
+    }
+
+    async getSize(): Promise<number> {
+        try {
+            return this.getDirectorySize(path.dirname(this.path));
+        } catch {
+            return 0;
+        }
+    }
+
+    private getDirectorySize(dir: string): number {
+        let size = 0;
+        const normalizedPath = path.join(dir, '*');
+
+        const paths = glob.sync(normalizedPath, { nodir: false });
+        if (!paths) {
+            return size;
+        }
+
+        for (const p of paths) {
+            if (fs.statSync(p).isFile()) {
+                size += fs.statSync(p).size;
+            } else if (fs.statSync(p).isDirectory()) {
+                size += this.getDirectorySize(p);
+            }
+        }
+
+        return size;
+    }
+
+    getPath(filename: string): string {
+        return path.join(this.path, filename);
+    }
+
+    protected deleteDirectory(dirPath: string): boolean {
+        if (!fs.statSync(dirPath).isDirectory()) {
+            throw new Error(`${dirPath} must be a directory`);
+        }
+
+        if (!dirPath.endsWith('/')) {
+            dirPath += '/';
+        }
+
+        const files = glob.sync(dirPath + '*', { mark: true });
+
+        if (!files) {
+            throw new Error('Error happened during glob');
+        }
+
+        for (const file of files) {
+            if (fs.statSync(file).isDirectory()) {
+                this.deleteDirectory(file);
+            } else {
+                fs.unlinkSync(file);
+            }
+        }
+
+        return fs.rmdirSync(dirPath);
+    }
+}

package/src/Cache/Adapters/Memory.ts

@@ -0,0 +1,57 @@
+import { Adapter } from "../Adapter";
+
+export class Memory implements Adapter {
+    public store: { [key: string]: { time: number, data: any } } = {};
+
+    constructor() {}
+    delWithStart(pattern: string): Promise<number> {
+        throw new Error("Method not implemented.");
+    }
+
+    async load(key: string, ttl: number, hash: string = ''): Promise<any> {
+        if (key && this.store[key]) {
+            const saved = this.store[key];
+            return (saved.time + ttl > Date.now() / 1000) ? saved.data : false;
+        }
+        return false;
+    }
+
+    async save(key: string, data: any, hash: string = ''): Promise<boolean | string | any[]> {
+        if (!key || !data) {
+            return false;
+        }
+
+        const saved = {
+            time: Date.now() / 1000,
+            data: data,
+        };
+
+        this.store[key] = saved;
+        return data;
+    }
+
+    async list(key: string): Promise<string[]> {
+        return [];
+    }
+
+    async purge(key: string, hash: string = ''): Promise<boolean> {
+        if (key && this.store[key]) {
+            delete this.store[key];
+            return true;
+        }
+        return false;
+    }
+
+    async flush(): Promise<boolean> {
+        this.store = {};
+        return true;
+    }
+
+    async ping(): Promise<boolean> {
+        return true;
+    }
+
+    async getSize(): Promise<number> {
+        return Object.keys(this.store).length;
+    }
+}

package/src/Cache/Adapters/None.ts

@@ -0,0 +1,36 @@
+import { Adapter } from "../Adapter";
+
+export class None implements Adapter {
+    constructor() {}
+    delWithStart(pattern: string): Promise<number> {
+        throw new Error("Method not implemented.");
+    }
+
+    async load(key: string, ttl: number, hash: string = ''): Promise<any> {
+        return false;
+    }
+
+    async save(key: string, data: any, hash: string = ''): Promise<boolean | string | any[]> {
+        return false;
+    }
+
+    async list(key: string): Promise<string[]> {
+        return [];
+    }
+
+    async purge(key: string, hash: string = ''): Promise<boolean> {
+        return true;
+    }
+
+    async flush(): Promise<boolean> {
+        return true;
+    }
+
+    async ping(): Promise<boolean> {
+        return true;
+    }
+
+    async getSize(): Promise<number> {
+        return 0;
+    }
+}

package/src/Cache/Adapters/Redis.ts

@@ -0,0 +1,106 @@
+import { RedisClientType, } from 'redis';
+import { Adapter } from "../Adapter";
+
+
+export class Redis implements Adapter {
+    protected redis: RedisClientType;
+
+    constructor(redis: RedisClientType) {
+        this.redis = redis;
+    }
+
+    async load(key: string, ttl: number, hash: string = ''): Promise<any> {
+        if (!hash) {
+            hash = key;
+        }
+
+        return new Promise((resolve) => {
+            try {
+                this.redis.get(key).then((redisString) => {
+                    if (!redisString) {
+                        resolve(null);
+                    }
+
+                    const cache = JSON.parse(redisString);
+                    if (cache != null && cache.time + ttl > Date.now() / 1000) {
+                        resolve(cache.data);
+                    } else {
+                        resolve(null);
+                    }
+                })
+                    .catch((e) => {
+                        console.error('redis error');
+                    })
+            }
+            catch (e) {
+                console.error('redis error');
+            }
+        })
+    }
+
+    async save(key: string, data: any, hash: string = ''): Promise<boolean | string | any[]> {
+        if (!key || !data) {
+            return Promise.resolve(false);
+        }
+
+        if (!hash) {
+            hash = key;
+        }
+
+        const value = JSON.stringify({
+            time: Date.now() / 1000,
+            data: data,
+        });
+
+        return this.redis.set(key, value).then(() => data).catch(() => false);
+    }
+
+    list(key: string): Promise<string[]> {
+
+        return this.redis.hKeys(key).then((keys) => keys || []);
+    }
+
+    async purge(key: string, hash: string = ''): Promise<boolean> {
+        if (hash) {
+            return this.redis.del(key).then((result) => !!result);
+        }
+
+        const result = await this.redis.del(key);
+
+        return !!result;
+    }
+
+    flush(): Promise<boolean> {
+        //@ts-ignore
+        return this.redis.flushall().then(() => true);
+    }
+
+    ping(): Promise<boolean> {
+        return this.redis.ping().then(() => true).catch(() => false);
+    }
+
+    getSize(): Promise<number> {
+        //@ts-ignore
+        return this.redis.dbsize();
+    }
+
+    async delWithStart(pattern: string): Promise<number> {
+        
+        let cur = 0;
+        let totalDeleted = 0;
+
+        do {
+            const {cursor, keys} = await this.redis.scan(cur, {
+                MATCH: `${pattern}:*`,
+                COUNT: 100, // Her taramada maksimum 100 anahtar döndür
+            }) as any;
+
+           
+            cur = Number(cursor);
+
+            await Promise.all(keys.map ((key: string) => this.redis.del(key)))
+        } while (cur !== 0);
+
+        return totalDeleted;
+    }
+}