@appconda/nextjs 1.0.18 → 1.0.19

package/dist/inputFile.js

@@ -0,0 +1,16 @@
+import { File } from "node-fetch-native-with-agent";
+import { realpathSync, readFileSync } from "fs";
+export class InputFile {
+    static fromBuffer(parts, name) {
+        return new File([parts], name);
+    }
+    static fromPath(path, name) {
+        const realPath = realpathSync(path);
+        const contents = readFileSync(realPath);
+        return this.fromBuffer(contents, name);
+    }
+    static fromPlainText(content, name) {
+        const arrayBytes = new TextEncoder().encode(content);
+        return this.fromBuffer(arrayBytes, name);
+    }
+}

package/dist/lib/Registry/Registry.js

@@ -0,0 +1,55 @@
+export class Registry {
+    constructor() {
+        /**
+         * List of all callbacks
+         */
+        this.callbacks = {};
+        /**
+         * List of all fresh resources
+         */
+        this.fresh = {};
+        /**
+         * List of all connections
+         */
+        this.registry = {
+            'default': {},
+        };
+        /**
+         * Current context
+         */
+        this._context = 'default';
+    }
+    /**
+     * Set a new connection callback
+     */
+    set(name, callback, fresh = false) {
+        if (this.registry[this._context].hasOwnProperty(name)) {
+            delete this.registry[this._context][name];
+        }
+        this.fresh[name] = fresh;
+        this.callbacks[name] = callback;
+        return this;
+    }
+    /**
+     * If connection has been created returns it, otherwise create and then return it
+     */
+    get(name, fresh = false) {
+        if (!this.registry[this._context].hasOwnProperty(name) || fresh || this.fresh[name]) {
+            if (!this.callbacks.hasOwnProperty(name)) {
+                throw new Error(`No callback named "${name}" found when trying to create connection`);
+            }
+            this.registry[this._context][name] = this.callbacks[name]();
+        }
+        return this.registry[this._context][name];
+    }
+    /**
+     * Set the current context
+     */
+    context(name) {
+        if (!this.registry.hasOwnProperty(name)) {
+            this.registry[name] = {};
+        }
+        this._context = name;
+        return this;
+    }
+}

package/dist/lib/Registry/index.js

@@ -0,0 +1 @@
+export * from './Registry';

package/dist/models.js

@@ -0,0 +1 @@
+export {};

package/dist/permission.js

@@ -0,0 +1,53 @@
+/**
+ * Helper class to generate permission strings for resources.
+ */
+export class Permission {
+}
+/**
+ * Generate read permission string for the provided role.
+ *
+ * @param {string} role
+ * @returns {string}
+ */
+Permission.read = (role) => {
+    return `read("${role}")`;
+};
+/**
+ * Generate write permission string for the provided role.
+ *
+ * This is an alias of update, delete, and possibly create.
+ * Don't use write in combination with update, delete, or create.
+ *
+ * @param {string} role
+ * @returns {string}
+ */
+Permission.write = (role) => {
+    return `write("${role}")`;
+};
+/**
+ * Generate create permission string for the provided role.
+ *
+ * @param {string} role
+ * @returns {string}
+ */
+Permission.create = (role) => {
+    return `create("${role}")`;
+};
+/**
+ * Generate update permission string for the provided role.
+ *
+ * @param {string} role
+ * @returns {string}
+ */
+Permission.update = (role) => {
+    return `update("${role}")`;
+};
+/**
+ * Generate delete permission string for the provided role.
+ *
+ * @param {string} role
+ * @returns {string}
+ */
+Permission.delete = (role) => {
+    return `delete("${role}")`;
+};

package/dist/query.js

@@ -0,0 +1,203 @@
+/**
+ * Helper class to generate query strings.
+ */
+export class Query {
+    /**
+     * Constructor for Query class.
+     *
+     * @param {string} method
+     * @param {AttributesTypes} attribute
+     * @param {QueryTypes} values
+     */
+    constructor(method, attribute, values) {
+        this.method = method;
+        this.attribute = attribute;
+        if (values !== undefined) {
+            if (Array.isArray(values)) {
+                this.values = values;
+            }
+            else {
+                this.values = [values];
+            }
+        }
+    }
+    /**
+     * Convert the query object to a JSON string.
+     *
+     * @returns {string}
+     */
+    toString() {
+        return JSON.stringify({
+            method: this.method,
+            attribute: this.attribute,
+            values: this.values,
+        });
+    }
+}
+/**
+ * Filter resources where attribute is equal to value.
+ *
+ * @param {string} attribute
+ * @param {QueryTypes} value
+ * @returns {string}
+ */
+Query.equal = (attribute, value) => new Query("equal", attribute, value).toString();
+/**
+ * Filter resources where attribute is not equal to value.
+ *
+ * @param {string} attribute
+ * @param {QueryTypes} value
+ * @returns {string}
+ */
+Query.notEqual = (attribute, value) => new Query("notEqual", attribute, value).toString();
+/**
+ * Filter resources where attribute is less than value.
+ *
+ * @param {string} attribute
+ * @param {QueryTypes} value
+ * @returns {string}
+ */
+Query.lessThan = (attribute, value) => new Query("lessThan", attribute, value).toString();
+/**
+ * Filter resources where attribute is less than or equal to value.
+ *
+ * @param {string} attribute
+ * @param {QueryTypes} value
+ * @returns {string}
+ */
+Query.lessThanEqual = (attribute, value) => new Query("lessThanEqual", attribute, value).toString();
+/**
+ * Filter resources where attribute is greater than value.
+ *
+ * @param {string} attribute
+ * @param {QueryTypes} value
+ * @returns {string}
+ */
+Query.greaterThan = (attribute, value) => new Query("greaterThan", attribute, value).toString();
+/**
+ * Filter resources where attribute is greater than or equal to value.
+ *
+ * @param {string} attribute
+ * @param {QueryTypes} value
+ * @returns {string}
+ */
+Query.greaterThanEqual = (attribute, value) => new Query("greaterThanEqual", attribute, value).toString();
+/**
+ * Filter resources where attribute is null.
+ *
+ * @param {string} attribute
+ * @returns {string}
+ */
+Query.isNull = (attribute) => new Query("isNull", attribute).toString();
+/**
+ * Filter resources where attribute is not null.
+ *
+ * @param {string} attribute
+ * @returns {string}
+ */
+Query.isNotNull = (attribute) => new Query("isNotNull", attribute).toString();
+/**
+ * Filter resources where attribute is between start and end (inclusive).
+ *
+ * @param {string} attribute
+ * @param {string | number} start
+ * @param {string | number} end
+ * @returns {string}
+ */
+Query.between = (attribute, start, end) => new Query("between", attribute, [start, end]).toString();
+/**
+ * Filter resources where attribute starts with value.
+ *
+ * @param {string} attribute
+ * @param {string} value
+ * @returns {string}
+ */
+Query.startsWith = (attribute, value) => new Query("startsWith", attribute, value).toString();
+/**
+ * Filter resources where attribute ends with value.
+ *
+ * @param {string} attribute
+ * @param {string} value
+ * @returns {string}
+ */
+Query.endsWith = (attribute, value) => new Query("endsWith", attribute, value).toString();
+/**
+ * Specify which attributes should be returned by the API call.
+ *
+ * @param {string[]} attributes
+ * @returns {string}
+ */
+Query.select = (attributes) => new Query("select", undefined, attributes).toString();
+/**
+ * Filter resources by searching attribute for value.
+ * A fulltext index on attribute is required for this query to work.
+ *
+ * @param {string} attribute
+ * @param {string} value
+ * @returns {string}
+ */
+Query.search = (attribute, value) => new Query("search", attribute, value).toString();
+/**
+ * Sort results by attribute descending.
+ *
+ * @param {string} attribute
+ * @returns {string}
+ */
+Query.orderDesc = (attribute) => new Query("orderDesc", attribute).toString();
+/**
+ * Sort results by attribute ascending.
+ *
+ * @param {string} attribute
+ * @returns {string}
+ */
+Query.orderAsc = (attribute) => new Query("orderAsc", attribute).toString();
+/**
+ * Return results after documentId.
+ *
+ * @param {string} documentId
+ * @returns {string}
+ */
+Query.cursorAfter = (documentId) => new Query("cursorAfter", undefined, documentId).toString();
+/**
+ * Return results before documentId.
+ *
+ * @param {string} documentId
+ * @returns {string}
+ */
+Query.cursorBefore = (documentId) => new Query("cursorBefore", undefined, documentId).toString();
+/**
+ * Return only limit results.
+ *
+ * @param {number} limit
+ * @returns {string}
+ */
+Query.limit = (limit) => new Query("limit", undefined, limit).toString();
+/**
+ * Filter resources by skipping the first offset results.
+ *
+ * @param {number} offset
+ * @returns {string}
+ */
+Query.offset = (offset) => new Query("offset", undefined, offset).toString();
+/**
+ * Filter resources where attribute contains the specified value.
+ *
+ * @param {string} attribute
+ * @param {string | string[]} value
+ * @returns {string}
+ */
+Query.contains = (attribute, value) => new Query("contains", attribute, value).toString();
+/**
+ * Combine multiple queries using logical OR operator.
+ *
+ * @param {string[]} queries
+ * @returns {string}
+ */
+Query.or = (queries) => new Query("or", undefined, queries.map((query) => JSON.parse(query))).toString();
+/**
+ * Combine multiple queries using logical AND operator.
+ *
+ * @param {string[]} queries
+ * @returns {string}
+ */
+Query.and = (queries) => new Query("and", undefined, queries.map((query) => JSON.parse(query))).toString();

package/dist/role.js

@@ -0,0 +1,93 @@
+/**
+ * Helper class to generate role strings for `Permission`.
+ */
+export class Role {
+    /**
+     * Grants access to anyone.
+     *
+     * This includes authenticated and unauthenticated users.
+     *
+     * @returns {string}
+     */
+    static any() {
+        return 'any';
+    }
+    /**
+     * Grants access to a specific user by user ID.
+     *
+     * You can optionally pass verified or unverified for
+     * `status` to target specific types of users.
+     *
+     * @param {string} id
+     * @param {string} status
+     * @returns {string}
+     */
+    static user(id, status = '') {
+        if (status === '') {
+            return `user:${id}`;
+        }
+        return `user:${id}/${status}`;
+    }
+    /**
+     * Grants access to any authenticated or anonymous user.
+     *
+     * You can optionally pass verified or unverified for
+     * `status` to target specific types of users.
+     *
+     * @param {string} status
+     * @returns {string}
+     */
+    static users(status = '') {
+        if (status === '') {
+            return 'users';
+        }
+        return `users/${status}`;
+    }
+    /**
+     * Grants access to any guest user without a session.
+     *
+     * Authenticated users don't have access to this role.
+     *
+     * @returns {string}
+     */
+    static guests() {
+        return 'guests';
+    }
+    /**
+     * Grants access to a team by team ID.
+     *
+     * You can optionally pass a role for `role` to target
+     * team members with the specified role.
+     *
+     * @param {string} id
+     * @param {string} role
+     * @returns {string}
+     */
+    static team(id, role = '') {
+        if (role === '') {
+            return `team:${id}`;
+        }
+        return `team:${id}/${role}`;
+    }
+    /**
+     * Grants access to a specific member of a team.
+     *
+     * When the member is removed from the team, they will
+     * no longer have access.
+     *
+     * @param {string} id
+     * @returns {string}
+     */
+    static member(id) {
+        return `member:${id}`;
+    }
+    /**
+     * Grants access to a user with the specified label.
+     *
+     * @param {string} name
+     * @returns  {string}
+     */
+    static label(name) {
+        return `label:${name}`;
+    }
+}

package/dist/service-client.js

@@ -0,0 +1,13 @@
+export class ServiceClient {
+    constructor(client) {
+        this.client = client;
+    }
+    async actionCall(actionName, payload) {
+        const apiPath = `/service/registry/${this.getServiceName()}/${actionName}`;
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('post', uri, apiHeaders, payload);
+    }
+}

package/dist/service.js

@@ -0,0 +1,22 @@
+export class Service {
+    constructor(client) {
+        this.client = client;
+    }
+    static flatten(data, prefix = '') {
+        let output = {};
+        for (const [key, value] of Object.entries(data)) {
+            let finalKey = prefix ? prefix + '[' + key + ']' : key;
+            if (Array.isArray(value)) {
+                output = { ...output, ...Service.flatten(value, finalKey) };
+            }
+            else {
+                output[finalKey] = value;
+            }
+        }
+        return output;
+    }
+}
+/**
+ * The size for chunked uploads in bytes.
+ */
+Service.CHUNK_SIZE = 5 * 1024 * 1024; // 5MB