vectors - load vector bucket and index at rest level

Signed-off-by: Amit Prinz Setter <alphaprinz@gmail.com>

Author: alphaprinz

src/endpoint/vector/ops/vector_bucket_get.js

@@ -9,9 +9,7 @@ async function post_get_vector_bucket(req, res) {
 
     dbg.log0("post_get_vector_bucket body =", req.body);
 
-    const vector_bucket_name = req.body.vectorBucketName;
-
-    const vb = await req.vector_sdk.get_vector_bucket({ vector_bucket_name});
+    const vb = req.vector_bucket;
 
     return {
         vectorBucket: {

src/endpoint/vector/ops/vector_index_get.js

@@ -10,13 +10,7 @@ async function post_get_index(req, res) {
 
     dbg.log0("post_get_index body =", req.body);
 
-    const vector_index_name = req.body.indexName;
-    const vector_bucket_name = req.body.vectorBucketName;
-
-    const vector_index_info = await req.vector_sdk.get_vector_index({
-        vector_index_name,
-        vector_bucket_name
-    });
+    const vector_index_info = req.vector_index;
 
     return {
         index: {

src/endpoint/vector/vector_rest.js

@@ -38,21 +38,81 @@ const RPC_ERRORS_TO_VECTOR = Object.freeze({ //TODO - validate
 });
 
 const VECTOR_OPS = js_utils.deep_freeze({
-    CreateVectorBucket: require('./ops/vector_bucket_create'),
-    GetVectorBucket: require('./ops/vector_bucket_get'),
-    DeleteVectorBucket: require('./ops/vector_bucket_delete'),
-    ListVectorBuckets: require('./ops/vector_list_vector_buckets'),
-    CreateIndex: require('./ops/vector_index_create'),
-    GetIndex: require('./ops/vector_index_get'),
-    ListIndexes: require('./ops/vector_index_list'),
-    DeleteIndex: require('./ops/vector_index_delete'),
-    PutVectors: require('./ops/vector_put_vectors'),
-    ListVectors: require('./ops/vector_list_vectors'),
-    QueryVectors: require('./ops/vector_query_vectors'),
-    DeleteVectors: require('./ops/vector_delete_vectors'),
-    PutVectorBucketPolicy: require('./ops/vector_put_vector_bucket_policy'),
-    GetVectorBucketPolicy: require('./ops/vector_get_vector_bucket_policy'),
-    DeleteVectorBucketPolicy: require('./ops/vector_delete_vector_bucket_policy'),
+    CreateVectorBucket: {
+        handler: require('./ops/vector_bucket_create'),
+        load_vector_bucket: false,
+        load_vector_index: false,
+    },
+    GetVectorBucket: {
+        handler: require('./ops/vector_bucket_get'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
+    DeleteVectorBucket: {
+        handler: require('./ops/vector_bucket_delete'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
+    ListVectorBuckets: {
+        handler: require('./ops/vector_list_vector_buckets'),
+        load_vector_bucket: false,
+        load_vector_index: false,
+    },
+    CreateIndex: {
+        handler: require('./ops/vector_index_create'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
+    GetIndex: {
+        handler: require('./ops/vector_index_get'),
+        load_vector_bucket: true,
+        load_vector_index: true,
+    },
+    ListIndexes: {
+        handler: require('./ops/vector_index_list'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
+    DeleteIndex: {
+        handler: require('./ops/vector_index_delete'),
+        load_vector_bucket: true,
+        load_vector_index: true,
+    },
+    PutVectors: {
+        handler: require('./ops/vector_put_vectors'),
+        load_vector_bucket: true,
+        load_vector_index: true,
+    },
+    ListVectors: {
+        handler: require('./ops/vector_list_vectors'),
+        load_vector_bucket: true,
+        load_vector_index: true,
+    },
+    QueryVectors: {
+        handler: require('./ops/vector_query_vectors'),
+        load_vector_bucket: true,
+        load_vector_index: true,
+    },
+    DeleteVectors: {
+        handler: require('./ops/vector_delete_vectors'),
+        load_vector_bucket: true,
+        load_vector_index: true,
+    },
+    PutVectorBucketPolicy: {
+        handler: require('./ops/vector_put_vector_bucket_policy'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
+    GetVectorBucketPolicy: {
+        handler: require('./ops/vector_get_vector_bucket_policy'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
+    DeleteVectorBucketPolicy: {
+        handler: require('./ops/vector_delete_vector_bucket_policy'),
+        load_vector_bucket: true,
+        load_vector_index: false,
+    },
 });
 
 async function vector_rest(req, res) {
@@ -121,22 +181,24 @@ async function handle_request(req, res) {
 
     http_utils.authorize_session_token(req, headers_options);
     authenticate_request(req);
-    await authorize_request(req);
+    await req.object_sdk.load_requesting_account(req);
+    await req.object_sdk.authorize_request_account(req);
 
     dbg.log1('VECTOR REQUEST', req.method, req.originalUrl, 'op', op_name, 'request_id', req.request_id, req.headers);
 
     //init vector_sdk here to avoid creating this object for s3 reqs that don't need it
     //TODO - find a better place to get BS?
     req.vector_sdk = new VectorSDK({bucketspace: req.object_sdk._get_bucketspace()});
-    const reply = await op.handler(req, res);
+    await req.vector_sdk.load_vector_bucket_and_index(req, op);
+    const reply = await op.handler.handler(req, res);
     dbg.log0("VECTOR reply =", reply);
 
     http_utils.send_reply(req, res, reply, options);
 }
 
 function authenticate_request(req) {
     try {
-        signature_utils.authenticate_request_by_service(req, req.account_sdk);
+        signature_utils.authenticate_request_by_service(req, req.object_sdk);
     } catch (err) {
         dbg.error('authenticate_request: ERROR', err.stack || err);
         if (err.code) {
@@ -147,12 +209,6 @@ function authenticate_request(req) {
     }
 }
 
-// authorize_request_account authorizes the account of the requester
-async function authorize_request(req) {
-    await req.account_sdk.load_requesting_account(req);
-    req.account_sdk.authorize_request_account(req);
-}
-
 function handle_error(req, res, err) {
     const vector_err =
         ((err instanceof VectorError) && err) ||

src/sdk/object_sdk.js

@@ -315,16 +315,14 @@ class ObjectSDK {
     }
 
     async authorize_request_account(req) {
-        const { bucket } = req.params;
+        const bucket = req.params?.bucket;
         const token = this.get_auth_token();
         // If the request is signed (authenticated)
         if (token) {
             signature_utils.authorize_request_account_by_token(token, this.requesting_account);
         }
         // check for a specific bucket
-        if (bucket && req.op_name !== 'put_bucket' && req.op_name !== 'post_vector_bucket' &&
-            req.op_name.indexOf('vector') === -1 //TODO - this line should be removed :)
-        ) {
+        if (bucket && req.op_name !== 'put_bucket' && req.op_name !== 'post_vector_bucket') {
             // ANONYMOUS: cannot work without bucket.
             // Return if the acount is anonymous
             if (this._get_bucketspace().is_nsfs_non_containerized_user_anonymous(token)) return;

src/sdk/vector_sdk.js

@@ -24,6 +24,18 @@ class VectorSDK {
         return this.bucketspace;
     }
 
+    //load the vector bucket and index (if handling the op requries it)
+    async load_vector_bucket_and_index(req, op) {
+        if (!op.load_vector_bucket) return;
+        const params = {
+            vector_bucket_name: req.body.vectorBucketName
+        };
+        req.vector_bucket = await this.get_vector_bucket(params);
+        if (!op.load_vector_index) return;
+        params.vector_index_name = req.body.indexName;
+        req.vector_index = await this.get_vector_index(params);
+    }
+
     //////////////////////////
     // VECTOR BUCKETS       //
     //////////////////////////

src/test/integration_tests/api/vectors/test_vectors_ops.js

@@ -106,7 +106,7 @@ mocha.describe('vectors_ops', function() {
                 }
             });
         });
-        
+
         mocha.it('should get a vector bucket', async function() {
             const beforeTs = Date.now();
             await create_vector_bucket(s3_vectors_client, created_vector_buckets, vector_bucket_name1);