@appconda/nextjs 1.0.34 → 1.0.35

package/dist/decorators/Cache.js

@@ -1,4 +1,4 @@
-import { Services } from '../Services';
+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(",")}}`;

package/dist/decorators/Invalidate.js

@@ -1,4 +1,4 @@
-import { Services } from '../Services';
+import { Services } from "lib/Services";
 export function Invalidate(keys) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;

package/dist/{Cache → lib/Cache}/Adapters/Filesystem.js

@@ -6,9 +6,6 @@ export class Filesystem {
         this.path = '';
         this.path = path;
     }
-    delWithStart(pattern) {
-        throw new Error("Method not implemented.");
-    }
     async load(key, ttl, hash = '') {
         const file = this.getPath(key);
         if (fs.existsSync(file) && (fs.statSync(file).mtime.getTime() + ttl * 1000 > Date.now())) {
@@ -99,4 +96,7 @@ export class Filesystem {
         }
         return fs.rmdirSync(dirPath);
     }
+    async delWithStart(pattern) {
+        return 0;
+    }
 }

package/dist/{Cache → lib/Cache}/Adapters/Memory.js

@@ -2,9 +2,6 @@ export class Memory {
     constructor() {
         this.store = {};
     }
-    delWithStart(pattern) {
-        throw new Error("Method not implemented.");
-    }
     async load(key, ttl, hash = '') {
         if (key && this.store[key]) {
             const saved = this.store[key];
@@ -43,4 +40,7 @@ export class Memory {
     async getSize() {
         return Object.keys(this.store).length;
     }
+    async delWithStart(pattern) {
+        return 0;
+    }
 }

package/dist/{Cache → lib/Cache}/Adapters/None.js

@@ -1,8 +1,5 @@
 export class None {
     constructor() { }
-    delWithStart(pattern) {
-        throw new Error("Method not implemented.");
-    }
     async load(key, ttl, hash = '') {
         return false;
     }
@@ -24,4 +21,7 @@ export class None {
     async getSize() {
         return 0;
     }
+    async delWithStart(pattern) {
+        return 0;
+    }
 }

package/dist/{Cache → lib/Cache}/Adapters/Sharding.js

@@ -19,9 +19,6 @@ export class Sharding {
         this.count = adapters.length;
         this.adapters = adapters;
     }
-    delWithStart(pattern) {
-        throw new Error("Method not implemented.");
-    }
     async load(key, ttl, hash = '') {
         const adapter = this.getAdapter(key);
         return await adapter.load(key, ttl, hash);
@@ -69,4 +66,7 @@ export class Sharding {
         }
         return (crc ^ (-1)) >>> 0;
     }
+    async delWithStart(pattern) {
+        return 0;
+    }
 }

package/dist/{Cache → lib/Cache}/index.d.ts

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

package/dist/{Cache → lib/Cache}/index.js

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

package/{types → dist/lib}/Services.d.ts

@@ -1,5 +1,5 @@
-import { Registry } from "./lib/Registry";
 import { Cache } from "./Cache";
+import { Registry } from "./Registry";
 export declare const registry: Registry;
 export declare class Services {
     static get Cache(): Cache;

package/dist/lib/Services.js

@@ -0,0 +1,13 @@
+import { Cache, Memory } from "./Cache";
+import { Registry } from "./Registry";
+export const registry = new Registry();
+registry.set('cache', () => {
+    const memoryAdapter = new Memory();
+    const cacheProvider = new Cache(memoryAdapter);
+    return cacheProvider;
+});
+export class Services {
+    static get Cache() {
+        return registry.get('cache');
+    }
+}

package/dist/services/node.js

@@ -1,3 +1,13 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Cache } from "decorators/Cache";
 import { ServiceClient } from "../service-client";
 export class Node extends ServiceClient {
     getServiceName() {
@@ -8,3 +18,9 @@ export class Node extends ServiceClient {
         return await this.actionCall('GetAllNodes', payload);
     }
 }
+__decorate([
+    Cache(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", Promise)
+], Node.prototype, "GetAllNodes", null);

package/package.json

@@ -2,7 +2,7 @@
   "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.34",
+  "version": "1.0.35",
   "license": "BSD-3-Clause",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,7 @@
     "url": "https://github.com/appconda/sdk-for-console"
   },
   "scripts": {
-    "tsc-build": "tsc"
+    "build": "tsc"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "8.3.2",

package/src/decorators/Cache.ts

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

package/src/decorators/CacheKey.ts

@@ -0,0 +1,9 @@
+
+export function CacheKey() {
+    return function (target: any, propertyKey: string | symbol, parameterIndex: number): void {
+        if (!target.__cacheKeys) {
+            target.__cacheKeys = [];
+        }
+        target.__cacheKeys.push({ propertyKey, parameterIndex });
+    };
+}

package/src/decorators/Invalidate.ts

@@ -0,0 +1,69 @@
+import { Services } from "lib/Services";
+
+
+export function Invalidate(keys: 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 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/{types/Cache/Adapter.d.ts → src/lib/Cache/Adapter.ts}

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

package/src/lib/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;
+    }
+
+    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);
+    }
+    async delWithStart(pattern: string): Promise<number> {
+        return 0;
+    }
+}

package/src/lib/Cache/Adapters/Memory.ts

@@ -0,0 +1,58 @@
+import { Adapter } from "../Adapter";
+
+export class Memory implements Adapter {
+    public store: { [key: string]: { time: number, data: any } } = {};
+
+    constructor() {}
+
+    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;
+    }
+
+    async delWithStart(pattern: string): Promise<number> {
+        return 0;
+    }
+}

package/src/lib/Cache/Adapters/None.ts

@@ -0,0 +1,36 @@
+import { Adapter } from "../Adapter";
+
+export class None implements Adapter {
+    constructor() {}
+
+    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;
+    }
+    async delWithStart(pattern: string): Promise<number> {
+        return 0;
+    }
+}

package/src/lib/Cache/Adapters/Sharding.ts

@@ -0,0 +1,88 @@
+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;
+        }
+
+      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;
+        }
+
+        async delWithStart(pattern: string): Promise<number> {
+            return 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;
+        })();
+    }