@rolder/kit 3.0.0-alpha.79 → 3.0.0-alpha.80

package/dist/tanstackFunctions/index.d.ts

@@ -1,2 +1,3 @@
 export * from './cookie';
 export * from './s3';
+export * from './surreal';

package/dist/tanstackFunctions/index.js

@@ -1,2 +1,3 @@
 export * from "./cookie/index.js";
 export * from "./s3/index.js";
+export * from "./surreal/index.js";

package/dist/tanstackFunctions/surreal/connection.d.ts

@@ -0,0 +1,9 @@
+import { type CodecOptions, Surreal } from 'surrealdb';
+export declare const getDB: (params?: {
+    url?: string;
+    namespace?: string;
+    database?: string;
+    username?: string;
+    password?: string;
+    codecOptions?: CodecOptions;
+} | undefined) => Promise<Surreal>;

package/dist/tanstackFunctions/surreal/connection.js

@@ -0,0 +1,49 @@
+import { createServerOnlyFn } from "@tanstack/react-start";
+import { getCookie } from "@tanstack/react-start/server";
+import { DateTime, Surreal } from "surrealdb";
+let db = null;
+const getDB = createServerOnlyFn(async (params = {})=>{
+    if (db?.isConnected) return db;
+    const locale = getCookie('locale') || 'ru-RU';
+    const timeZone = getCookie('tz') || 'UTC';
+    const instance = new Surreal({
+        codecOptions: params.codecOptions || {
+            valueDecodeVisitor (value) {
+                if (value instanceof DateTime) return new Date(value.toDate()).toLocaleDateString(locale, {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    timeZone
+                });
+                return value;
+            }
+        }
+    });
+    try {
+        const url = params.url || process.env.SURREALDB_URL;
+        if (!url) throw new Error('Missing required SurrealDB URL');
+        const namespace = params.namespace || process.env.SURREALDB_NAMESPACE;
+        if (!namespace) throw new Error('Missing required SurrealDB namespace');
+        const database = params.database || process.env.SURREALDB_DATABASE;
+        if (!database) throw new Error('Missing required SurrealDB database');
+        const username = params.username || process.env.SURREALDB_USERNAME;
+        const password = params.password || process.env.SURREALDB_PASSWORD;
+        if (username && password) await instance.connect(url, {
+            authentication: {
+                username,
+                password
+            }
+        });
+        else await instance.connect(url);
+        await instance.use({
+            namespace,
+            database
+        });
+        db = instance;
+        return instance;
+    } catch (error) {
+        console.error('Failed to connect to SurrealDB:', error);
+        db = null;
+        throw error;
+    }
+});
+export { getDB };

package/dist/tanstackFunctions/surreal/deafaultCrud.d.ts

@@ -0,0 +1,2 @@
+export declare const surrealDeleteFn: import("@tanstack/start-client-core").RequiredFetcher<undefined, (data: string) => string, Promise<void>>;
+export declare const surrealUnsubscribeFn: import("@tanstack/start-client-core").RequiredFetcher<undefined, (data: string) => string, Promise<void>>;

package/dist/tanstackFunctions/surreal/deafaultCrud.js

@@ -0,0 +1,18 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getDB } from "./connection.js";
+import { deserialize } from "./deserialize.js";
+const surrealDeleteFn = createServerFn({
+    method: 'POST'
+}).inputValidator((data)=>data).handler(async ({ data })=>{
+    const db = await getDB();
+    const id = deserialize(data);
+    await db.delete(id);
+});
+const surrealUnsubscribeFn = createServerFn({
+    method: 'POST'
+}).inputValidator((data)=>data).handler(async ({ data })=>{
+    const db = await getDB();
+    const live = await db.liveOf(data);
+    await live.kill();
+});
+export { surrealDeleteFn, surrealUnsubscribeFn };

package/dist/tanstackFunctions/surreal/deserialize.d.ts

@@ -0,0 +1,17 @@
+import { RecordId } from 'surrealdb';
+/**
+ * Type that converts specified string paths to RecordId, others stay as their original types
+ */
+type DeserializeResult<T, IdPaths extends string = never> = T extends string ? RecordId<string> : T extends (infer U)[] ? U extends object ? {
+    [K in keyof U]: K extends IdPaths ? RecordId<string> : U[K];
+}[] : DeserializeResult<U, IdPaths>[] : T extends object ? T extends Date ? T : {
+    [K in keyof T]: K extends IdPaths ? RecordId<string> : T[K];
+} : T;
+/**
+ * Deserializes DTO back to SurrealDB Record recursively based on specified ID paths
+ */
+export declare function deserialize<T, K extends keyof T & string>(dto: T[], idPaths: K[]): DeserializeResult<T, K>[];
+export declare function deserialize<T, K extends keyof T & string>(dto: T, idPaths: K[]): DeserializeResult<T, K>;
+export declare function deserialize<T>(dto: T[]): DeserializeResult<T>[];
+export declare function deserialize<T>(dto: T): DeserializeResult<T>;
+export {};

package/dist/tanstackFunctions/surreal/deserialize.js

@@ -0,0 +1,46 @@
+import { RecordId } from "surrealdb";
+const extractTableName = (str)=>{
+    const match = str.match(/^([^:]+):/);
+    return match ? match[1] : null;
+};
+const isRecordIdFormat = (str)=>/^[^:]+:.+$/.test(str);
+function deserialize(dto, idPaths) {
+    if (Array.isArray(dto)) return dto.map((item)=>convertStringsToRecordIds(item, idPaths || []));
+    return convertStringsToRecordIds(dto, idPaths || []);
+}
+const convertStringsToRecordIds = (obj, idPaths, currentPath = '')=>{
+    if (null == obj) return obj;
+    if (Array.isArray(obj)) {
+        if (idPaths.includes(currentPath)) return obj.map((item)=>{
+            if ('string' == typeof item && isRecordIdFormat(item)) {
+                const tableName = extractTableName(item);
+                if (tableName) return new RecordId(tableName, item.split(':')[1]);
+            }
+            return item;
+        });
+        return obj.map((item, index)=>convertStringsToRecordIds(item, idPaths, `${currentPath}[${index}]`));
+    }
+    if ('object' == typeof obj && !(obj instanceof Date)) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)){
+            const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+            if ('string' == typeof value) {
+                const shouldConvert = idPaths.includes(fieldPath) && isRecordIdFormat(value);
+                if (shouldConvert) {
+                    const tableName = extractTableName(value);
+                    if (tableName) result[key] = new RecordId(tableName, value.split(':')[1]);
+                    else result[key] = value;
+                } else result[key] = value;
+            } else result[key] = convertStringsToRecordIds(value, idPaths, fieldPath);
+        }
+        return result;
+    }
+    if ('string' == typeof obj) {
+        if (0 === idPaths.length && isRecordIdFormat(obj)) {
+            const tableName = extractTableName(obj);
+            if (tableName) return new RecordId(tableName, obj.split(':')[1]);
+        }
+    }
+    return obj;
+};
+export { deserialize };

package/dist/tanstackFunctions/surreal/encryption.d.ts

@@ -0,0 +1,6 @@
+type EncryptionInstance = {
+    encrypt(text: string): string;
+    decrypt(encryptedText: string): string;
+};
+export declare const encryptionFn: (secretHash: string) => EncryptionInstance;
+export {};

package/dist/tanstackFunctions/surreal/encryption.js

@@ -0,0 +1,30 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { createServerOnlyFn } from "@tanstack/react-start";
+const encryptionFn = createServerOnlyFn((secretHash)=>{
+    class Encryption {
+        key;
+        constructor(secretHash){
+            this.key = Buffer.from(secretHash, 'hex');
+        }
+        encrypt(text) {
+            const algorithm = 'aes-256-cbc';
+            const iv = randomBytes(16);
+            const cipher = createCipheriv(algorithm, this.key, iv);
+            let encrypted = cipher.update(text, 'utf8', 'hex');
+            encrypted += cipher.final('hex');
+            return `${iv.toString('hex')}:${encrypted}`;
+        }
+        decrypt(encryptedText) {
+            const algorithm = 'aes-256-cbc';
+            const parts = encryptedText.split(':');
+            const iv = Buffer.from(parts[0], 'hex');
+            const encrypted = parts[1];
+            const decipher = createDecipheriv(algorithm, this.key, iv);
+            let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+            decrypted += decipher.final('utf8');
+            return decrypted;
+        }
+    }
+    return new Encryption(secretHash);
+});
+export { encryptionFn };

package/dist/tanstackFunctions/surreal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './connection';
+export * from './deafaultCrud';
+export * from './deserialize';
+export * from './encryption';

package/dist/tanstackFunctions/surreal/index.js

@@ -0,0 +1,4 @@
+export * from "./connection.js";
+export * from "./deafaultCrud.js";
+export * from "./deserialize.js";
+export * from "./encryption.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolder/kit",
-  "version": "3.0.0-alpha.79",
+  "version": "3.0.0-alpha.80",
   "type": "module",
   "exports": {
     ".": {