@appconda/nextjs 1.0.17 → 1.0.19

package/dist/Cache/Adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/Cache/Adapters/Filesystem.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+export class Filesystem {
+    constructor(path) {
+        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())) {
+            return fs.readFileSync(file, 'utf8');
+        }
+        return false;
+    }
+    async save(key, data, hash = '') {
+        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) {
+            throw new Error(e.message);
+        }
+    }
+    async list(key) {
+        return [];
+    }
+    async purge(key, hash = '') {
+        const file = this.getPath(key);
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+            return true;
+        }
+        return false;
+    }
+    async flush() {
+        return this.deleteDirectory(this.path);
+    }
+    async ping() {
+        return fs.existsSync(this.path) && fs.accessSync(this.path, fs.constants.W_OK | fs.constants.R_OK);
+    }
+    async getSize() {
+        try {
+            return this.getDirectorySize(path.dirname(this.path));
+        }
+        catch {
+            return 0;
+        }
+    }
+    getDirectorySize(dir) {
+        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) {
+        return path.join(this.path, filename);
+    }
+    deleteDirectory(dirPath) {
+        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/dist/Cache/Adapters/Memory.js

@@ -0,0 +1,46 @@
+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];
+            return (saved.time + ttl > Date.now() / 1000) ? saved.data : false;
+        }
+        return false;
+    }
+    async save(key, data, hash = '') {
+        if (!key || !data) {
+            return false;
+        }
+        const saved = {
+            time: Date.now() / 1000,
+            data: data,
+        };
+        this.store[key] = saved;
+        return data;
+    }
+    async list(key) {
+        return [];
+    }
+    async purge(key, hash = '') {
+        if (key && this.store[key]) {
+            delete this.store[key];
+            return true;
+        }
+        return false;
+    }
+    async flush() {
+        this.store = {};
+        return true;
+    }
+    async ping() {
+        return true;
+    }
+    async getSize() {
+        return Object.keys(this.store).length;
+    }
+}

package/dist/Cache/Adapters/None.js

@@ -0,0 +1,27 @@
+export class None {
+    constructor() { }
+    delWithStart(pattern) {
+        throw new Error("Method not implemented.");
+    }
+    async load(key, ttl, hash = '') {
+        return false;
+    }
+    async save(key, data, hash = '') {
+        return false;
+    }
+    async list(key) {
+        return [];
+    }
+    async purge(key, hash = '') {
+        return true;
+    }
+    async flush() {
+        return true;
+    }
+    async ping() {
+        return true;
+    }
+    async getSize() {
+        return 0;
+    }
+}

package/dist/Cache/Adapters/Redis.js

@@ -0,0 +1,79 @@
+export class Redis {
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async load(key, ttl, hash = '') {
+        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, data, hash = '') {
+        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) {
+        return this.redis.hKeys(key).then((keys) => keys || []);
+    }
+    async purge(key, hash = '') {
+        if (hash) {
+            return this.redis.del(key).then((result) => !!result);
+        }
+        const result = await this.redis.del(key);
+        return !!result;
+    }
+    flush() {
+        //@ts-ignore
+        return this.redis.flushall().then(() => true);
+    }
+    ping() {
+        return this.redis.ping().then(() => true).catch(() => false);
+    }
+    getSize() {
+        //@ts-ignore
+        return this.redis.dbsize();
+    }
+    async delWithStart(pattern) {
+        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
+            });
+            cur = Number(cursor);
+            await Promise.all(keys.map((key) => this.redis.del(key)));
+        } while (cur !== 0);
+        return totalDeleted;
+    }
+}

package/dist/Cache/Adapters/Sharding.js

@@ -0,0 +1,72 @@
+export class Sharding {
+    constructor(adapters) {
+        this.count = 0;
+        this.crc32Table = (() => {
+            let c;
+            const table = [];
+            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;
+        })();
+        if (adapters.length === 0) {
+            throw new Error('No adapters provided');
+        }
+        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);
+    }
+    async save(key, data, hash = '') {
+        return this.getAdapter(key).save(key, data, hash);
+    }
+    async list(key) {
+        return this.getAdapter(key).list(key);
+    }
+    async purge(key, hash = '') {
+        return this.getAdapter(key).purge(key, hash);
+    }
+    async flush() {
+        let result = true;
+        for (const adapter of this.adapters) {
+            result = await adapter.flush() ? result : false;
+        }
+        return result;
+    }
+    async ping() {
+        for (const adapter of this.adapters) {
+            if (!adapter.ping()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async getSize() {
+        let size = 0;
+        for (const adapter of this.adapters) {
+            size += await adapter.getSize();
+        }
+        return size;
+    }
+    getAdapter(key) {
+        const hash = this.crc32(key);
+        const index = hash % this.count;
+        return this.adapters[index];
+    }
+    crc32(str) {
+        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;
+    }
+}

package/dist/Cache/Cache.js

@@ -0,0 +1,51 @@
+export class Cache {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    constructKey(key) {
+        if (Array.isArray(key)) {
+            key = key.join(':');
+        }
+        return key;
+    }
+    static setCaseSensitivity(value) {
+        return this.caseSensitive = value;
+    }
+    async load(key, ttl = 60 * 60 * 24, hash = '') {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+        return await this.adapter.load(key, ttl, hash);
+    }
+    async save(key, data, hash = '') {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+        return this.adapter.save(key, data, hash);
+    }
+    async list(key) {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        return this.adapter.list(key);
+    }
+    async purge(key, hash = '') {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+        return this.adapter.purge(key, hash);
+    }
+    async flush() {
+        return this.adapter.flush();
+    }
+    async ping() {
+        return this.adapter.ping();
+    }
+    async getSize() {
+        return this.adapter.getSize();
+    }
+    async delWithStart(keys) {
+        const pattern = this.constructKey(keys);
+        return this.adapter.delWithStart(pattern);
+    }
+}
+Cache.caseSensitive = false;

package/dist/Cache/index.js

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

package/dist/Services.js

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

package/dist/actions/actionClient.js

@@ -0,0 +1,35 @@
+import { DEFAULT_SERVER_ERROR_MESSAGE, createSafeActionClient } from "next-safe-action";
+export const actionClient = createSafeActionClient({
+    handleServerError(e) {
+        /* if (
+          e instanceof ResourceNotFoundError ||
+          e instanceof AuthorizationError ||
+          e instanceof InvalidInputError ||
+          e instanceof UnknownError ||
+          e instanceof AuthenticationError ||
+          e instanceof OperationNotAllowedError ||
+          e instanceof AppcondaException
+        ) {
+          return e.message;
+        } */
+        // eslint-disable-next-line no-console -- This error needs to be logged for debugging server-side errors
+        console.error("SERVER ERROR: ", e);
+        return DEFAULT_SERVER_ERROR_MESSAGE;
+    },
+});
+/* export const authenticatedActionClient = actionClient.use(async ({ next }) => {
+  const session = await getServerSession(authOptions);
+  if (!session?.user) {
+    throw new AuthenticationError("Not authenticated");
+  }
+
+  const userId = session.user.id;
+
+  const user = await getUser(userId);
+  if (!user) {
+    throw new AuthorizationError("User not found");
+  }
+
+  return next({ ctx: { user } });
+});
+ */ 

package/dist/actions/index.js

@@ -0,0 +1 @@
+export * from './nodes';

package/dist/actions/nodes.js

@@ -0,0 +1,9 @@
+'use server';
+import { actionClient } from "./actionClient";
+import { getSDKForCurrentUser } from "@/getSDKForCurrentUser";
+export const getAllNodesAction = actionClient
+    // .schema(listModelsSchema)
+    .action(async ({ parsedInput }) => {
+    const { node } = await getSDKForCurrentUser();
+    return await node.GetAllNodes();
+});