retoolrpc 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Retool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# `retoolrpc` Javascript Client Package
+
+Welcome to the `retoolrpc` client package! This package serves as the client-side component for the `retoolrpc` project. For detailed information and usage instructions, please refer to our official documentation.
+
+## About `retoolrpc`
+
+Retool RPC (Remote Procedure Call) is a fast, secure solution for connecting your own codebase to Retool. You define functions in your backend and then call them from Retool apps using a Retool RPC resource.
+
+## Documentation
+
+For more detailed information, examples, and usage guidelines, please refer to our official documentation. The documentation provides in-depth insights into the `retoolrpc` client package, including installation instructions and comprehensive usage guides.
+
+[Link to Documentation](https://docs.retool.com/retool-rpc)
+
+## Getting Started
+
+To get started with the `retoolrpc` client package, please consult our documentation, which provides step-by-step instructions and examples to help you integrate and use this package effectively in your projects.
+
+## Issues and Support
+
+If you encounter any issues, have questions, or need assistance, please feel free to reach out to our support team or report issues on our GitHub repository.
+
+[Link to GitHub Repository](https://github.com/tryretool/retoolrpc)
+
+## License
+
+This project is licensed under the MIT License. Please refer to the LICENSE file in this repository for more details.
+
+---
+
+Feel free to replace the placeholders with the actual links and relevant information for your project. This README section provides a clear introduction to the `retoolrpc` client package and directs users to your official documentation and support channels.

package/dist/cjs/example.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var dedent = require('ts-dedent');
+var rpc$1 = require('./rpc-5628288a.js');
+require('uuid');
+require('node-fetch');
+require('abort-controller');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dedent__default = /*#__PURE__*/_interopDefaultLegacy(dedent);
+
+/*
+ * This is an example of how to use the Retool RPC.
+ */
+/*
+ * Initialize the RPC.
+ */
+const rpc = new rpc$1.RetoolRPC({
+    apiToken: 'secret-api-token',
+    host: 'http://localhost:3001',
+    resourceId: 'resource-uuid',
+    environmentName: 'production',
+    pollingIntervalMs: 1000,
+    logLevel: 'info',
+});
+/*
+ * Register custom functions with the RPC.
+ */
+rpc.register({
+    name: 'helloWorld',
+    arguments: {
+        firstName: { type: 'string', description: 'Enter your first name', required: true },
+        lastName: { type: 'string', description: 'Enter your last name', required: true },
+    },
+    implementation: async (args, _context) => {
+        return `Hello, ${args.firstName} ${args.lastName}!`;
+    },
+});
+rpc.register({
+    name: 'helloWorldWithPermissions',
+    arguments: {
+        firstName: { type: 'string', description: 'Enter your first name', required: true },
+        lastName: { type: 'string', description: 'Enter your last name', required: true },
+    },
+    permissions: {
+        groupNames: ['Trailblazers'],
+        userEmails: ['trailblazers@retool.com'],
+    },
+    implementation: async (args, _context) => {
+        return `Hello, ${args.firstName} ${args.lastName}!`;
+    },
+});
+rpc.register({
+    name: 'plusTwoNumbers',
+    arguments: {
+        firstNumber: { type: 'number', description: 'Enter your first number', required: true },
+        secondNumber: { type: 'number', description: 'Enter your second number', required: true },
+    },
+    implementation: async (args, _context) => {
+        return args.firstNumber + args.secondNumber;
+    },
+});
+class CustomTestError extends Error {
+    constructor(message, stack, code, details) {
+        super(message);
+        this.name = 'CustomTestError';
+        this.stack = stack;
+        this.code = code;
+        this.details = details;
+    }
+}
+rpc.register({
+    name: 'throwsCustomError',
+    arguments: {},
+    implementation: async () => {
+        throw new CustomTestError(`This is the error message`, dedent__default["default"] `
+        Error: Something went wrong
+            at bar (file:///path/to/your/code.js:15:7)
+            at foo (file:///path/to/your/code.js:10:5)
+            at main (file:///path/to/your/code.js:5:1)
+      `, 500, {
+            additionalInfo: ['foo', 'bar'],
+            baz: 123,
+        });
+    },
+});
+rpc.register({
+    name: 'throwsStringError',
+    arguments: {},
+    implementation: async () => {
+        throw 'This is a string error';
+    },
+});
+rpc.register({
+    name: 'echoInputs',
+    arguments: {
+        stringInput: { type: 'string', description: 'string input' },
+        numberInput: { type: 'number', description: 'number input' },
+        booleanInput: { type: 'boolean', description: 'boolean input' },
+        dictInput: { type: 'dict', description: 'dict input' },
+        jsonInput: { type: 'json', description: 'json input' },
+        stringArrayInput: { type: 'string', array: true, description: 'string array input' },
+        numberArrayInput: { type: 'number', array: true, description: 'number array input' },
+        booleanArrayInput: { type: 'boolean', array: true, description: 'boolean array input' },
+        dictArrayInput: { type: 'dict', array: true, description: 'dict array input' },
+        jsonArrayInput: { type: 'json', array: true, description: 'json array input' },
+    },
+    implementation: async (args, _context) => {
+        return {
+            stringInput: args.stringInput,
+            numberInput: args.numberInput,
+            booleanInput: args.booleanInput,
+            dictInput: args.dictInput,
+            jsonInput: args.jsonInput,
+            stringArrayInput: args.stringArrayInput,
+            numberArrayInput: args.numberArrayInput,
+            booleanArrayInput: args.booleanArrayInput,
+            dictArrayInput: args.dictArrayInput,
+            jsonArrayInput: args.jsonArrayInput,
+        };
+    },
+});
+rpc.listen();

package/dist/cjs/index.js

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rpc = require('./rpc-5628288a.js');
+require('uuid');
+require('ts-dedent');
+require('node-fetch');
+require('abort-controller');
+
+// See documentation about mixin:
+// https://www.typescriptlang.org/docs/handbook/mixins.html
+// https://lit.dev/docs/composition/mixins/#typing-the-subclass
+function sequelizeMixin(Base) {
+    class RetoolRPCSequelize extends Base {
+        registerModel(args) {
+            registerModel({ rpc: this, ...args });
+        }
+    }
+    return RetoolRPCSequelize;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function registerModel({ rpc, model, readAttributes, writeAttributes, findByAttributes, }) {
+    const modelName = capitalize(model.name);
+    // this will give us not just the name of the attribute, but also their type
+    const modelAttributes = model.getAttributes();
+    readAttributes = readAttributes || Object.keys(modelAttributes);
+    writeAttributes = writeAttributes || Object.keys(modelAttributes);
+    findByAttributes = findByAttributes || readAttributes;
+    const findByAttributeArgs = {};
+    for (const attr of findByAttributes) {
+        findByAttributeArgs[attr] = { type: 'string' };
+    }
+    const writeAttributeArgs = {};
+    for (const attr of writeAttributes) {
+        writeAttributeArgs[attr] = { type: 'string' };
+    }
+    // register a set of functions for a model
+    rpc.register({
+        name: `${modelName} > create`,
+        arguments: writeAttributeArgs,
+        implementation: async (args) => {
+            if (typeof args !== 'object' || Array.isArray(args)) {
+                throw 'attributes must be an object';
+            }
+            const record = await model.create(args);
+            const recordJson = {};
+            for (const key of readAttributes || Object.keys(args)) {
+                recordJson[key] = record.get(key);
+            }
+            return recordJson;
+        },
+    });
+    rpc.register({
+        name: `${modelName} > update`,
+        arguments: {
+            primaryKey: { type: 'string', required: true },
+            ...writeAttributeArgs,
+        },
+        implementation: async ({ primaryKey, ...attributes }) => {
+            return model.update(attributes, {
+                where: {
+                    [model.primaryKeyAttribute]: primaryKey,
+                },
+            });
+        },
+    });
+    rpc.register({
+        name: `${modelName} > createOrUpdate`,
+        arguments: {
+            findAttributes: { type: 'dict', required: true },
+            ...writeAttributeArgs,
+        },
+        implementation: async ({ findAttributes, ...writeAttributes }) => {
+            // Note: this is susceptible to race condition if there is no unique index
+            // on the find attributes. It's the user's responsibility to avoid
+            // duplicate inserts
+            return model.findOne({ where: findAttributes }).then(function (record) {
+                // update
+                if (record) {
+                    return record.update(writeAttributes);
+                }
+                // insert
+                return model.create({
+                    ...findAttributes,
+                    ...writeAttributes,
+                });
+            });
+        },
+    });
+    rpc.register({
+        name: `${modelName} > findAll`,
+        arguments: {
+            offset: { type: 'number' },
+            limit: { type: 'number' },
+        },
+        implementation: async ({ offset, limit }) => {
+            return model.findAll({
+                attributes: readAttributes,
+                raw: true,
+                offset: offset || 0,
+                limit: limit || 100,
+            });
+        },
+    });
+    rpc.register({
+        name: `${modelName} > findByPk`,
+        arguments: {
+            primaryKey: { type: 'string', required: true },
+        },
+        implementation: async ({ primaryKey }) => {
+            return model.findByPk(primaryKey, {
+                attributes: readAttributes,
+                raw: true,
+            });
+        },
+    });
+    rpc.register({
+        name: `${modelName} > findBy`,
+        arguments: findByAttributeArgs,
+        implementation: async (attributesValues) => {
+            return model.findAll({
+                where: attributesValues,
+                attributes: readAttributes,
+                raw: true,
+            });
+        },
+    });
+}
+
+exports.RetoolRPC = rpc.RetoolRPC;
+exports.sequelizeMixin = sequelizeMixin;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+"{\"type\":\"commonjs\"}"