crudjt 1.0.0-beta.0

package/test-neon-package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "test-neon-package",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "crudjt": "file:../crudjt-1.0.0-beta.0.tgz"
+  }
+}

package/test-neon-package/test.js

@@ -0,0 +1,198 @@
+// This binding was generated automatically to ensure consistency across languages
+// Generated using ChatGPT (GPT-5) from the canonical Ruby SDK
+// API is stable and production-ready
+
+const CRUDJT = require('crudjt');
+const { performance } = require('perf_hooks');
+const os = require('os');
+
+function sortObjectByKeyRecursive(obj) {
+    if (typeof obj !== 'object' || obj === null) return obj;
+
+    const sorted = Object.keys(obj).sort().reduce((result, key) => {
+        result[key] = sortObjectByKeyRecursive(obj[key]);
+        return result;
+    }, {});
+
+    return sorted;
+}
+
+function objectToString(obj) {
+    return JSON.stringify(sortObjectByKeyRecursive(obj));
+}
+
+if (process.env.CRUDJT_AUTOTEST_ALLOWED !== 'true') {
+  console.log("Denied run autotest for this environment. Set CRUDJT_AUTOTEST_ALLOWED='true'");
+  return;
+}
+
+console.log(`OS: ${process.platform}`);
+console.log(`CPU: ${os.arch()}`);
+
+async function main() {
+    await CRUDJT.Config.startMaster({
+      secret_key: 'Cm7B68NWsMNNYjzMDREacmpe5sI1o0g40ZC9w1yQW3WOes7Gm59UsittLOHR2dciYiwmaYq98l3tG8h9yXVCxg=='
+    });
+
+    // without metadata
+    console.log('Checking without metadata...');
+    let data = { user_id: 42, role: 11 };
+    let expectedData = sortObjectByKeyRecursive({ data: { ...data } });
+
+    let edData = { user_id: 42, role: 8 };
+    let expectedEdData = sortObjectByKeyRecursive({ data: { ...edData } });
+
+    let token = await CRUDJT.create(data);
+
+    console.log(objectToString(await CRUDJT.read(token)) === objectToString(expectedData));
+    console.log(await CRUDJT.update(token, edData) === true);
+    console.log(objectToString(await CRUDJT.read(token)) === objectToString(expectedEdData));
+    console.log(await CRUDJT.delete(token) === true);
+    console.log(await CRUDJT.read(token) === null);
+
+    // with metadata
+    console.log('Checking ttl...');
+    data = { user_id: 42, role: 11 };
+
+    let ttl = 5;
+    let tokenWithttl = await CRUDJT.create(data, ttl);
+
+    let expectedttl = ttl;
+    for (let i = 0; i < ttl; i++) {
+        console.log(objectToString(await CRUDJT.read(tokenWithttl)) === objectToString({ metadata: { ttl: expectedttl }, data: data }));
+        expectedttl -= 1;
+
+        await new Promise(resolve => setTimeout(resolve, 1000)); // Затримка 1 секунда
+    }
+    console.log(await CRUDJT.read(tokenWithttl) === null);
+
+    // when expired ttl
+    console.log('when expired ttl');
+    data = { user_id: 42, role: 11 };
+    ttl = 1;
+    token = await CRUDJT.create(data, ttl);
+    await new Promise(resolve => setTimeout(resolve, ttl * 1000)); // Затримка на ttl секунд
+    console.log(await CRUDJT.read(token) === null);
+    console.log(await CRUDJT.update(token, data) === false);
+    console.log(await CRUDJT.delete(token) === false);
+
+    console.log(await CRUDJT.update(token, data) === false);
+    console.log(await CRUDJT.read(token) === null);
+
+    // with silence_read
+    console.log("Checking silence_read...");
+    data = { user_id: 42, role: 11 };
+    let silence_read = 6;
+    let tokenWithsilence_read = await CRUDJT.create(data, null, silence_read);
+
+    let expectedsilence_read = silence_read - 1;
+    for (let i = 0; i < silence_read; i++) {
+        console.log(objectToString(await CRUDJT.read(tokenWithsilence_read)) === objectToString({ metadata: { silence_read: expectedsilence_read }, data: data }));
+        expectedsilence_read -= 1;
+    }
+    console.log(await CRUDJT.read(tokenWithsilence_read) === null);
+
+    // with ttl and silence_read
+    console.log("Checking ttl and silence_read...");
+    data = { user_id: 42, role: 11 };
+    ttl = 5;
+    silence_read = 5;
+    expectedttl = 5;
+    expectedsilence_read = silence_read - 1;
+    let tokenWithttlAndsilence_read = await CRUDJT.create(data, ttl, silence_read);
+
+    for (let i = 0; i < silence_read; i++) {
+        console.log(objectToString(await CRUDJT.read(tokenWithttlAndsilence_read)) === objectToString({ metadata: { ttl: expectedttl, silence_read: expectedsilence_read }, data: data }));
+        expectedttl -= 1;
+        expectedsilence_read -= 1;
+
+        await new Promise(resolve => setTimeout(resolve, 1000)); // sleep 1 second
+    }
+    console.log(await CRUDJT.read(tokenWithttlAndsilence_read) === null);
+
+    // with scale load
+    const REQUESTS = 40_000;
+
+    for (let j = 0; j < 10; j++) {
+        let tokens = [];
+        data = {
+            user_id: 414243,
+            role: 11,
+            devices: {
+                ios_expired_at: "new Date().toString()",
+                android_expired_at: "new Date().toString()",
+                mobile_app_expired_at: "new Date().toString()",
+                external_api_integration_expired_at: "new Date().toString()",
+            },
+            a: 42
+        };
+        edData = { user_id: 42, role: 11 };
+
+        console.log('Checking scale load...');
+
+        console.log('when creates 40k tokens');
+        let start = performance.now();
+        for (let i = 0; i < REQUESTS; i++) {
+            tokens.push(await CRUDJT.create(data));
+        }
+        console.log(`Elapsed time: ${((performance.now() - start) / 1000).toFixed(3)}`);
+
+        console.log('when reads 40k tokens');
+        let index = Math.floor(Math.random() * REQUESTS);
+        start = performance.now();
+        for (let i = 0; i < REQUESTS; i++) {
+            await CRUDJT.read(tokens[index]);
+        }
+        console.log(`Elapsed time: ${((performance.now() - start) / 1000).toFixed(3)}`);
+
+        console.log('when updates 40k tokens');
+        start = performance.now();
+        for (let i = 0; i < REQUESTS; i++) {
+            await CRUDJT.update(tokens[i], edData);
+        }
+        console.log(`Elapsed time: ${((performance.now() - start) / 1000).toFixed(3)}`);
+
+        console.log('when deletes 40k tokens');
+        start = performance.now();
+        for (let i = 0; i < REQUESTS; i++) {
+            await CRUDJT.delete(tokens[i]);
+        }
+        console.log(`Elapsed time: ${((performance.now() - start) / 1000).toFixed(3)}`);
+    }
+
+    console.log('when caches after read from file system');
+
+    const ttlGH = 2;
+
+    data = {
+        user_id: 414243,
+        role: 11,
+        devices: {
+            ios_expired_at: new Date().toString(),
+            android_expired_at: new Date().toString(),
+            mobile_app_expired_at: new Date().toString(),
+            external_api_integration_expired_at: new Date().toString(),
+        },
+        a: 42
+    };
+
+    let previoustokens = [];
+
+    for (let i = 0; i < REQUESTS; i++) {
+        previoustokens.push(await CRUDJT.create(data));
+    }
+    for (let i = 0; i < REQUESTS; i++) {
+        await CRUDJT.create(data);
+    }
+
+    for (let i = 0; i < ttlGH; i++) {
+        let start = performance.now();
+        for (let j = 0; j < REQUESTS; j++) {
+            await CRUDJT.read(previoustokens[j]);
+        }
+        console.log(`Elapsed time: ${((performance.now() - start) / 1000).toFixed(3)}`);
+    }
+    await CRUDJT.Config.shutdownServer();
+}
+
+main().catch(console.error);

package/token_service.proto

@@ -0,0 +1,47 @@
+syntax = "proto3";
+
+package token;
+
+service TokenService {
+  rpc CreateToken(CreateTokenRequest) returns (CreateTokenResponse);
+  rpc ReadToken(ReadTokenRequest) returns (ReadTokenResponse);
+  rpc UpdateToken(UpdateTokenRequest) returns (UpdateTokenResponse);
+  rpc DeleteToken(DeleteTokenRequest) returns (DeleteTokenResponse);
+}
+
+message CreateTokenRequest {
+  bytes packed_data = 1;
+  int64 ttl = 2;
+  int64 silence_read = 3;
+}
+
+message CreateTokenResponse {
+  string token = 1;
+}
+
+message ReadTokenRequest {
+  string token = 1;
+}
+
+message ReadTokenResponse {
+  bytes packed_data = 1;
+}
+
+message UpdateTokenRequest {
+  string token = 1;
+  bytes packed_data = 2;
+  int64 ttl = 3;
+  int64 silence_read = 4;
+}
+
+message UpdateTokenResponse {
+  bool result = 1;
+}
+
+message DeleteTokenRequest {
+  string token = 1;
+}
+
+message DeleteTokenResponse {
+  bool result = 1;
+}

package/token_service_client.js

@@ -0,0 +1,33 @@
+// This binding was generated automatically to ensure consistency across languages
+// Generated using ChatGPT (GPT-5) from the canonical Ruby SDK
+// API is stable and production-ready
+
+const grpc = require('@grpc/grpc-js');
+const protoLoader = require('@grpc/proto-loader');
+const path = require('path');
+
+const PROTO_PATH = path.join(__dirname, 'token_service.proto');
+
+const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+});
+
+const proto = grpc.loadPackageDefinition(packageDefinition);
+const tokenProto = proto.token;
+
+/**
+ * Factory for create stub
+ * @param {string} address - "host:port"
+ */
+function createStub(address) {
+  return new tokenProto.TokenService(
+    address,
+    grpc.credentials.createInsecure()
+  );
+}
+
+module.exports = { createStub };

package/validation.js

@@ -0,0 +1,72 @@
+// This binding was generated automatically to ensure consistency across languages
+// Generated using ChatGPT (GPT-5) from the canonical Ruby SDK
+// API is stable and production-ready
+
+const U64_MAX = BigInt(2) ** BigInt(64) - BigInt(1);
+
+const MAX_HASH_SIZE = 256;
+
+const ERROR_ALREADY_STARTED = 0;
+const ERROR_NOT_STARTED = 1;
+const ERROR_SECRET_KEY_NOT_SET = 2;
+
+const ERROR_MESSAGES = {
+  [ERROR_ALREADY_STARTED]: 'CRUDJT already started',
+  [ERROR_NOT_STARTED]: 'CRUDJT has not started',
+  [ERROR_SECRET_KEY_NOT_SET]: 'Secret key is blank'
+};
+
+
+class Validation {
+  static errorMessage(code) {
+    return Validation.ERROR_MESSAGES[code] || `Unknown error (${code})`;
+  }
+
+  static validateInsertion(hash, ttl, silence_read) {
+    if (typeof hash !== 'object' || hash === null || Array.isArray(hash)) {
+      throw new Error("Must be a Hash (Object)");
+    }
+    if (ttl != -1 && !(BigInt(ttl) > 0 && BigInt(ttl) <= U64_MAX)) {
+      throw new Error("ttl should be greater than 0 and less than 2^64");
+    }
+    if (silence_read !== -1 && !(BigInt(silence_read) > 0 && BigInt(silence_read) <= U64_MAX)) {
+      throw new Error("silence_read should be greater than 0 and less than 2^64");
+    }
+  }
+
+  static validateToken(token) {
+    if (typeof token !== 'string') {
+      throw new Error("token must be a String");
+    }
+    if (token.length < 1) {
+      throw new Error("token can't be blank");
+    }
+  }
+
+  static validateHashBytesize(hashBytesize) {
+    if (hashBytesize > Validation.MAX_HASH_SIZE) {
+      throw new Error(`Hash can not be bigger than ${Validation.MAX_HASH_SIZE} bytesize`);
+    }
+  }
+
+  static validateSecretKey(key) {
+    let decoded;
+    try {
+      decoded = Buffer.from(key, 'base64');
+
+      if (Buffer.from(decoded.toString('base64'), 'base64').length !== decoded.length) {
+        throw new Error();
+      }
+    } catch {
+      throw new TypeError(`'secret_key' must be a valid Base64 string`);
+    }
+
+    if (![32, 48, 64].includes(decoded.length)) {
+      throw new TypeError(`'secret_key' must be exactly 32, 48, or 64 bytes. Got ${decoded.length} bytes`);
+    }
+
+    return true;
+  }
+}
+
+module.exports = Validation;