@aravinthan_p/appnest-app-sdk-utils 0.0.1

package/appnestFunctions/dbFunction/db.js

@@ -0,0 +1,624 @@
+const { getParentLayerConfigObject, getTraceId } = require('../utils/contextWrapper');
+const { makeSparrowAppAPICall } = require('../utils/axiosWrapper');
+const { DB_API } = require('../utils/apiConstants');
+
+const validateKey = ({ key }) => {
+    try {
+        if (typeof key !== 'string') {
+            throw new Error('Key must be a string');
+        }
+        if (key.length === 0) {
+            throw new Error('Key must be a non-empty string');
+        }
+        if (key.length > 1000) {
+            throw new Error('Key must be less than 1000 characters');
+        }
+        return true;
+    } catch (error) {
+        console.error("$Db - validateKey - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const validateValue = ({ value, dataType }) => {
+    try {
+        if (dataType === 'STRING') {
+            if (typeof value !== 'string') {
+                throw new Error('Value must be a string');
+            }
+        }
+        if (dataType === 'LIST') {
+            if (!Array.isArray(value)) {
+                throw new Error('Value must be an array');
+            }
+        }
+        if (dataType === 'MAP') {
+            const isPlainObject = typeof value === 'object' && value !== null && !Array.isArray(value);
+            if (!isPlainObject) {
+                throw new Error('Value must be an object');
+            }
+            try {
+                const jsonString = JSON.stringify(value);
+                const parsed = JSON.parse(jsonString);
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                    throw new Error('Value must be a valid JSON object');
+                }
+            } catch (error) {
+                console.error("$Db - validateValue - error:", JSON.stringify(error));
+                throw error;
+            }
+        }
+        if (dataType === 'NUMBER') {
+            if (typeof value !== 'number') {
+                throw new Error('Value must be a number');
+            }
+        }
+        if (dataType === 'BOOLEAN') {
+            if (typeof value !== 'boolean') {
+                throw new Error('Value must be a boolean');
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        console.error("$Db - validateValue - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const get = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'get',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - get - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const create = async ({ key }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'STRING' });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'create',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - create - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const update = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'STRING' });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'update',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - update - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const deleteOperation = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'delete',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - deleteOperation - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const stringGet = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'get',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - stringGet - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const stringCreate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'STRING' });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'set',
+            operationMeta: {
+                value,
+            }
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - stringSet - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const stringUpdate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'STRING' });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'update',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - stringUpdate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const stringDelete = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'STRING',
+            operationType: 'delete',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - stringDelete - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const string = {
+    get: stringGet,
+    create: stringCreate,
+    update: stringUpdate,
+    delete: stringDelete,
+}
+
+const numberGet = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'NUMBER',
+            operationType: 'get',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - numberGet - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const numberCreate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'NUMBER' });
+        const apiPayload = {
+            key,
+            dataType: 'NUMBER',
+            operationType: 'create',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - numberCreate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const numberUpdate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'NUMBER' });
+        const apiPayload = {
+            key,
+            dataType: 'NUMBER',
+            operationType: 'update',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - numberUpdate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const numberDelete = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'NUMBER',
+            operationType: 'delete',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - numberDelete - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const numberIncrement = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'NUMBER',
+            operationType: 'increment',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - numberIncrement - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const numberDecrement = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'NUMBER',
+            operationType: 'decrement',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - numberDecrement - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const number = {
+    get: numberGet,
+    create: numberCreate,
+    update: numberUpdate,
+    delete: numberDelete,
+    increment: numberIncrement,
+    decrement: numberDecrement,
+}
+
+const listGet = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'get',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - listGet - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const listCreate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'LIST' });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'create',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - listCreate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const listUpdate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'LIST' });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'update',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - listUpdate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+
+const listAppend = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'LIST' });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'append',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - listAppend - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const listPrepend = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'LIST' });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'prepend',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - listPrepend - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const listUpdateItemAtIndex = async ({ key, value, index }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'LIST' });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'updateItemAtIndex',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - listUpdateItemAtIndex - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const listRemoveItemAtIndex = async ({ key, index }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'LIST',
+            operationType: 'removeItemAtIndex',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - listRemoveItemAtIndex - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const list = {
+    get: listGet,
+    create: listCreate,
+    update: listUpdate,
+    append: listAppend,
+    prepend: listPrepend,
+    updateItemAtIndex: listUpdateItemAtIndex,
+    removeItemAtIndex: listRemoveItemAtIndex,
+}
+
+
+const mapGet = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'MAP',
+            operationType: 'get',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - mapGet - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const mapCreate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'MAP' });
+        if (typeof value !== 'object') {
+            throw new Error('Value must be an object');
+        }
+        const apiPayload = {
+            key,
+            dataType: 'MAP',
+            operationType: 'create',
+            operationMeta: {
+                value,
+            }
+        }
+        console.log("$Db - mapCreate - apiPayload:", JSON.stringify(apiPayload));
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - mapCreate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const mapUpdate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'MAP' });
+        const apiPayload = {
+            key,
+            dataType: 'MAP',
+            operationType: 'update',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - mapUpdate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const mapDelete = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'MAP',
+            operationType: 'delete',
+        }
+    }
+    catch (error) {
+        console.error("$Db - mapDelete - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const map = {
+    get: mapGet,
+    create: mapCreate,
+    update: mapUpdate,
+    delete: mapDelete,
+}
+
+
+const booleanGet = async ({ key }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'BOOLEAN' });
+        const apiPayload = {
+            key,
+            dataType: 'BOOLEAN',
+            operationType: 'get',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - booleanGet - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const booleanCreate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'BOOLEAN' });
+        const apiPayload = {
+            key,
+            dataType: 'BOOLEAN',
+            operationType: 'create',
+            operationMeta: {
+                value,
+            }
+        }
+        console.log("$Db - booleanCreate - apiPayload:", JSON.stringify(apiPayload));
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - booleanCreate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const booleanUpdate = async ({ key, value }) => {
+    try {
+        validateKey({ key });
+        validateValue({ value, dataType: 'BOOLEAN' });
+        const apiPayload = {
+            key,
+            dataType: 'BOOLEAN',
+            operationType: 'update',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    } catch (error) {
+        console.error("$Db - booleanUpdate - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const booleanDelete = async ({ key }) => {
+    try {
+        validateKey({ key });
+        const apiPayload = {
+            key,
+            dataType: 'BOOLEAN',
+            operationType: 'delete',
+        }
+        return await dbAPIWrapper({ apiPayload });
+    }
+    catch (error) {
+        console.error("$Db - booleanDelete - error:", JSON.stringify(error));
+        throw error;
+    }
+}
+
+const boolean = {
+    get: booleanGet,
+    create: booleanCreate,
+    update: booleanUpdate,
+    delete: booleanDelete,
+}
+
+
+const dbAPIWrapper = async ({ apiPayload }) => {
+    try {
+        const parentLayerConfigObject = getParentLayerConfigObject();
+        const requestBody = {
+            userInstalledId: parentLayerConfigObject.userInstalledId,
+            ...apiPayload
+        };
+        console.log("$Db - dbAPIWrapper - requestBody:", JSON.stringify(requestBody));
+        const response = await makeSparrowAppAPICall({
+            method: DB_API.COMMON.method,
+            endpoint: DB_API.COMMON.endpoint,
+            requestBody
+        });
+        console.log("$Db - dbAPIWrapper - response:", JSON.stringify(response));
+        return { data: response?.data, status: response?.status };
+    } catch (error) {
+        console.error("$Db - dbAPIWrapper - error:", JSON.stringify(error));
+        throw error;
+    }
+};
+
+
+
+const $db = {
+    get,
+    create,
+    update,
+    delete: deleteOperation,
+    string,
+    number,
+    list,
+    map,
+    boolean,
+};
+
+module.exports = {
+    $db
+};

package/appnestFunctions/fileFunction/file.MD

@@ -0,0 +1,57 @@
+# $file — File Storage SDK
+
+The `$file` module provides file storage helpers: signed URLs for upload/download, delete, list, and existence check.
+
+---
+
+## Import / Usage
+
+```javascript
+const { $file } = require('<path-to-sdk>/appnestFunctions');
+// or
+const { $file } = require('appnest-app-sdk-utils');
+```
+
+---
+
+## Common Parameters
+
+| Parameter   | Type   | Required | Default  | Description        |
+|------------|--------|----------|----------|--------------------|
+| path       | string | yes      | —        | File key/path      |
+| visibility | string | no       | `PUBLIC` | `PUBLIC` or `PRIVATE` |
+
+**Return shape:** `Promise<{ data, status }>` unless noted.
+
+---
+
+## API
+
+| Method        | Signature | Description |
+|---------------|-----------|-------------|
+| getUploadUrl  | `$file.getUploadUrl({ path, visibility })` | Get a signed URL for uploading a file. |
+| getDownloadUrl| `$file.getDownloadUrl({ path, visibility })` | Get a signed URL for reading/downloading a file. |
+| delete        | `$file.delete({ path, visibility })` | Delete a file at the given path. |
+| list          | `$file.list({ path, visibility })` | List objects under the given path. |
+| exists        | `$file.exists({ path, visibility })` | Check if a file exists at the path. |
+
+---
+
+## Examples
+
+```javascript
+// Get upload URL (default PUBLIC)
+const upload = await $file.getUploadUrl({ path: 'reports/2026-02-09.csv' });
+
+// Get download URL (private)
+const read = await $file.getDownloadUrl({ path: 'reports/2026-02-09.csv', visibility: 'PRIVATE' });
+
+// Delete file
+await $file.delete({ path: 'reports/old.csv' });
+
+// List files under prefix
+const listResult = await $file.list({ path: 'reports/' });
+
+// Check existence
+const existsResult = await $file.exists({ path: 'reports/2026-02-09.csv' });
+```