@rockster/core 0.0.1

package/tasks/functions/create-task-message-find.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskMessageFind = createTaskMessageFind;
+const task_request_1 = require("../requests/task.request");
+const task_message_find_1 = require("../models/task-message-find");
+const decorators_1 = require("../../controllers/decorators");
+function createTaskMessageFind(object) {
+    const actionName = object
+        .naming
+        .findAction;
+    task_request_1.TaskRequest.prototype[actionName] =
+        function (actionContent, requestContext) {
+            return this.find(object, actionContent, requestContext);
+        };
+    Reflect.defineMetadata('design:paramtypes', [task_message_find_1.TaskMessageFind, object], task_request_1.TaskRequest.prototype, actionName);
+    (0, decorators_1.Action)({
+        public: object.settings.public,
+        response: () => object.MessageModel,
+        isArray: true
+    })(task_request_1.TaskRequest.prototype, actionName);
+    (0, decorators_1.ActionContent)()(task_request_1.TaskRequest.prototype, actionName, 0);
+    (0, decorators_1.RequestContext)()(task_request_1.TaskRequest.prototype, actionName, 1);
+}

package/tasks/functions/create-task-message-model.d.ts

@@ -0,0 +1,3 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { ITaskObject } from "../interfaces/task-object";
+export declare function createTaskMessageModel(object: ObjectNote<ITaskObject>): any;

package/tasks/functions/create-task-message-model.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskMessageModel = createTaskMessageModel;
+const class_pipe_1 = require("@rockster/class-pipe");
+const create_new_class_1 = require("../../database/functions/create-new-class");
+const task_message_1 = require("../models/task-message");
+function createTaskMessageModel(object) {
+    const TaskMessageModel = (0, create_new_class_1.createNewClass)(object.naming.model, task_message_1.TaskMessage);
+    (0, class_pipe_1.IsType)(() => object.payload())(TaskMessageModel.prototype, 'payload');
+    return TaskMessageModel;
+}

package/tasks/functions/create-task-message-receptor.d.ts

@@ -0,0 +1,3 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { ITaskObject } from "../interfaces/task-object";
+export declare function createTaskMessageReceptor(object: ObjectNote<ITaskObject>): void;

package/tasks/functions/create-task-message-receptor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskMessageReceptor = createTaskMessageReceptor;
+const task_request_1 = require("../requests/task.request");
+const action_decorator_1 = require("../../controllers/decorators/actions/action.decorator");
+const controllers_1 = require("../../controllers");
+function createTaskMessageReceptor(object) {
+    const actionName = object
+        .naming
+        .postAction;
+    const Payload = object.payload();
+    task_request_1.TaskRequest.prototype[actionName] =
+        function (actionContent, requestContext) {
+            return this.create(object, actionContent, requestContext);
+        };
+    Reflect.defineMetadata('design:paramtypes', [Payload, object], task_request_1.TaskRequest.prototype, actionName);
+    (0, action_decorator_1.Action)({
+        public: object.settings.public,
+        response: () => object.MessageModel
+    })(task_request_1.TaskRequest.prototype, actionName);
+    (0, controllers_1.ActionContent)()(task_request_1.TaskRequest.prototype, actionName, 0);
+    (0, controllers_1.RequestContext)()(task_request_1.TaskRequest.prototype, actionName, 1);
+}

package/tasks/functions/create-task-message-retry.d.ts

@@ -0,0 +1,3 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { ITaskObject } from "../interfaces/task-object";
+export declare function createTaskMessageRetry(object: ObjectNote<ITaskObject>): void;

package/tasks/functions/create-task-message-retry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskMessageRetry = createTaskMessageRetry;
+const task_request_1 = require("../requests/task.request");
+const action_decorator_1 = require("../../controllers/decorators/actions/action.decorator");
+const controllers_1 = require("../../controllers");
+function createTaskMessageRetry(object) {
+    const actionName = object
+        .naming
+        .retryAction;
+    task_request_1.TaskRequest.prototype[actionName] =
+        function (actionContent, requestContext) {
+            return this.retry(object, actionContent, requestContext);
+        };
+    Reflect.defineMetadata('design:paramtypes', [object.MessageModel, object], task_request_1.TaskRequest.prototype, actionName);
+    (0, action_decorator_1.Action)({
+        public: object.settings.public,
+        response: () => object.MessageModel
+    })(task_request_1.TaskRequest.prototype, actionName);
+    (0, controllers_1.ActionContent)()(task_request_1.TaskRequest.prototype, actionName, 0);
+    (0, controllers_1.RequestContext)()(task_request_1.TaskRequest.prototype, actionName, 1);
+}

package/tasks/functions/create-task-message-schema.d.ts

@@ -0,0 +1,182 @@
+import { ITaskNaming } from "../interfaces/task-naming";
+export declare function createTaskMessageSchema(naming: ITaskNaming): import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: string;
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: string;
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: string;
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastModifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lastModifiedAt";
+            tableName: string;
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: string;
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: string;
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        internalError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "internalError";
+            tableName: string;
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: string;
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        partitionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "partitionId";
+            tableName: string;
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runtimeMS: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runtimeMS";
+            tableName: string;
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/tasks/functions/create-task-message-schema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskMessageSchema = createTaskMessageSchema;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const tasks_1 = require("@rockster/common/tasks");
+function createTaskMessageSchema(naming) {
+    return (0, pg_core_1.pgTable)(naming.table, {
+        id: (0, pg_core_1.varchar)().primaryKey(),
+        status: (0, pg_core_1.varchar)().default(tasks_1.TaskMessageStatus.pending),
+        createdAt: (0, pg_core_1.timestamp)({ withTimezone: true }).default((0, drizzle_orm_1.sql) `NOW() AT TIME ZONE 'UTC'`),
+        lastModifiedAt: (0, pg_core_1.timestamp)({ withTimezone: true }).default((0, drizzle_orm_1.sql) `NOW() AT TIME ZONE 'UTC'`),
+        attempts: (0, pg_core_1.integer)().default(0),
+        error: (0, pg_core_1.jsonb)(),
+        internalError: (0, pg_core_1.jsonb)(),
+        payload: (0, pg_core_1.jsonb)().notNull(),
+        partitionId: (0, pg_core_1.integer)().notNull(),
+        runtimeMS: (0, pg_core_1.integer)()
+    });
+}

package/tasks/functions/create-task-message-trigger.d.ts

@@ -0,0 +1,2 @@
+import { ITaskNaming } from "../interfaces/task-naming";
+export declare function createTaskMessageTrigger(naming: ITaskNaming): string;

package/tasks/functions/create-task-message-trigger.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskMessageTrigger = createTaskMessageTrigger;
+function createTaskMessageTrigger(naming) {
+    return `
+      CREATE OR REPLACE FUNCTION ${naming.function}() RETURNS TRIGGER AS $$
+      BEGIN
+         PERFORM pg_notify('${naming.channel}', row_to_json(NEW)::TEXT);
+         RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER ${naming.trigger}
+      AFTER INSERT ON ${naming.table}
+      FOR EACH ROW
+      EXECUTE FUNCTION ${naming.function}();
+   `;
+}

package/tasks/functions/create-task-naming.d.ts

@@ -0,0 +1,2 @@
+import { ITaskNaming } from "../interfaces/task-naming";
+export declare function createTaskNaming(taskClassName: string): ITaskNaming;

package/tasks/functions/create-task-naming.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskNaming = createTaskNaming;
+const radash_1 = require("radash");
+function createTaskNaming(taskClassName) {
+    const partitions = {};
+    const withoutTask = taskClassName.replace(/task/ig, '');
+    const baseName = (0, radash_1.snake)(withoutTask);
+    const preffix = 'task_';
+    const baseNaming = {
+        retryAction: `retry${withoutTask}`,
+        postAction: `post${withoutTask}`,
+        findAction: `find${withoutTask}`,
+        model: `${withoutTask}TaskMessage`,
+        table: `${preffix}${baseName}`,
+        trigger: `${preffix}trigger_${baseName}`,
+        function: `${preffix}notify_${baseName}`,
+        channel: `${preffix}channel_${baseName}`
+    };
+    baseNaming.partition = (id) => {
+        if (partitions[id])
+            return partitions[id];
+        return partitions[id] = {
+            channel: `${baseNaming.channel}_${id}`,
+            function: `${baseNaming.function}_${id}`,
+            table: `${baseNaming.table}_${id}`,
+            trigger: `${baseNaming.trigger}_${id}`
+        };
+    };
+    return baseNaming;
+}

package/tasks/functions/generate-entity-id.d.ts

@@ -0,0 +1 @@
+export declare const generateEntityId: (size?: number) => string;

package/tasks/functions/generate-entity-id.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEntityId = void 0;
+const nanoid_1 = require("nanoid");
+exports.generateEntityId = (0, nanoid_1.customAlphabet)('0123456789abcdefghijklmnopqrstuvwxyz', 12);

package/tasks/functions/get-check-table-exists-script.d.ts

@@ -0,0 +1 @@
+export declare function getCheckTableExistsScript(tableName: string): string;

package/tasks/functions/get-check-table-exists-script.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCheckTableExistsScript = getCheckTableExistsScript;
+function getCheckTableExistsScript(tableName) {
+    return `
+      SELECT EXISTS (
+         SELECT 1 FROM pg_partitioned_table p
+         JOIN pg_class c ON c.oid = p.partrelid
+         WHERE c.relname = '${tableName}'
+      )
+   `;
+}

package/tasks/functions/get-create-table-partition-script.d.ts

@@ -0,0 +1,2 @@
+import { ITaskNaming } from "../interfaces/task-naming";
+export declare function getCreateTablePartitionScript(naming: ITaskNaming, partitionId: number): string;

package/tasks/functions/get-create-table-partition-script.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateTablePartitionScript = getCreateTablePartitionScript;
+function getCreateTablePartitionScript(naming, partitionId) {
+    const script = `
+      CREATE TABLE ${naming.partition(partitionId).table} PARTITION OF ${naming.table} 
+      FOR VALUES IN (${partitionId});
+   `;
+    return script;
+}

package/tasks/functions/get-create-table-script.d.ts

@@ -0,0 +1 @@
+export declare function getCreateTablescript(tableName: string): string;

package/tasks/functions/get-create-table-script.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateTablescript = getCreateTablescript;
+function getCreateTablescript(tableName) {
+    const script = `
+      CREATE TABLE ${tableName}
+      (
+         id               varchar                                                                     not null,
+         status           varchar                     default 'pending'                               not null,
+         "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),                                     
+         "lastModifiedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+         attempts         integer   default 0                                                         not null,
+         error            jsonb,
+         "internalError"  jsonb,
+         payload          jsonb                                                                       not null,
+         "partitionId"    integer                                                                     not null,
+         "runtimeMS"      integer                                                                           
+      )
+      PARTITION BY LIST ("partitionId");
+   `;
+    return script;
+}

package/tasks/functions/get-database-connection-name.d.ts

@@ -0,0 +1 @@
+export declare function getDatabaseConnectionName(manager?: boolean): string;

package/tasks/functions/get-database-connection-name.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDatabaseConnectionName = getDatabaseConnectionName;
+function getDatabaseConnectionName(manager = false) {
+    return manager
+        ? `task_manager_${process.pid}`
+        : `task_worker_${process.pid}`;
+}

package/tasks/functions/get-database-uri.d.ts

@@ -0,0 +1 @@
+export declare const getDatabaseUri: (applicationName: string) => string;

package/tasks/functions/get-database-uri.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDatabaseUri = void 0;
+const getDatabaseUri = (applicationName) => {
+    const options = core.options.database;
+    return `postgresql://${options.username}:${options.password}@${options.host}:${options.port}/${options.database}?connection_timeout=${options.connectTimeoutMS}&application_name=${applicationName}`;
+};
+exports.getDatabaseUri = getDatabaseUri;

package/tasks/functions/get-partitions-of-table-script.d.ts

@@ -0,0 +1 @@
+export declare function getPartitionsOfTableScript(tableName: string): string;

package/tasks/functions/get-partitions-of-table-script.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPartitionsOfTableScript = getPartitionsOfTableScript;
+function getPartitionsOfTableScript(tableName) {
+    return `
+      SELECT inhrelid::regclass AS "tableName"
+         FROM pg_inherits
+      WHERE inhparent = '${tableName}'::regclass;
+   `;
+}

package/tasks/functions/get-pending-task-script.d.ts

@@ -0,0 +1,2 @@
+import { ITaskNaming } from "../interfaces/task-naming";
+export declare function getPendingTaskScript(naming: ITaskNaming): string;

package/tasks/functions/get-pending-task-script.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPendingTaskScript = getPendingTaskScript;
+const tasks_1 = require("@rockster/common/tasks");
+function getPendingTaskScript(naming) {
+    return `
+      WITH ${naming.table} AS (
+         SELECT * FROM ${naming.table}
+         WHERE status = '${tasks_1.TaskMessageStatus.pending}'
+         ORDER BY "createdAt" ASC
+         LIMIT 1000
+         FOR UPDATE SKIP LOCKED
+      )
+      UPDATE ${naming.table}
+      SET status = '${tasks_1.TaskMessageStatus.processing}', "lastModifiedAt" = (now())
+      WHERE id IN (SELECT id FROM ${naming.table})
+      RETURNING *;
+   `;
+}

package/tasks/functions/parse-task-message-search.d.ts

@@ -0,0 +1,20 @@
+export declare enum FieldType {
+    string = "string",
+    numeric = "numeric",
+    integer = "integer",
+    object = "object",
+    array = "array",
+    date = "date",
+    boolean = "boolean"
+}
+type RootField = {
+    name: string;
+    type: FieldType;
+};
+type WhereBuilderResult = {
+    query: string;
+    params: any[];
+    withParams: string;
+};
+export declare function parseTaskMessageSearch(conditionString: string, rootAlias: string, validRootFields: RootField[]): WhereBuilderResult;
+export {};

package/tasks/functions/parse-task-message-search.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldType = void 0;
+exports.parseTaskMessageSearch = parseTaskMessageSearch;
+var FieldType;
+(function (FieldType) {
+    FieldType["string"] = "string";
+    FieldType["numeric"] = "numeric";
+    FieldType["integer"] = "integer";
+    FieldType["object"] = "object";
+    FieldType["array"] = "array";
+    FieldType["date"] = "date";
+    FieldType["boolean"] = "boolean";
+})(FieldType || (exports.FieldType = FieldType = {}));
+function parseTaskMessageSearch(conditionString, rootAlias = 'task', validRootFields) {
+    const regex = /([a-zA-Z0-9_\.]+)\s*(=|<>|<|<=|>|>=|LIKE|ILIKE)\s*('[^']*'|\d+(\.\d+)?|true|false)/g;
+    const whereClauses = [];
+    const params = [];
+    let match;
+    const fieldMap = new Map(validRootFields.map(field => [field.name, field.type]));
+    while ((match = regex.exec(conditionString)) !== null) {
+        let [_, property, operator, value] = match;
+        let paramIndex = `$${params.length + 1}`;
+        let jsonPath;
+        const propertyParts = property.split(".");
+        const rootField = propertyParts[0];
+        const fieldType = fieldMap.get(rootField);
+        if (!fieldType) {
+            throw new Error(`Invalid field: ${rootField}`);
+        }
+        if (fieldType === FieldType.array) {
+            jsonPath = `${rootAlias}.${rootField} @> '[{"${propertyParts.slice(1).join(".")}": ${paramIndex}}]'`;
+        }
+        else if (fieldType === FieldType.object) {
+            jsonPath = `${rootAlias}.${rootField}` + propertyParts.slice(1).map((p, i) => `${i === 0 && propertyParts.length > 2 ? '->' : '->>'} '${p}' `).join("");
+        }
+        else {
+            jsonPath = `${rootAlias}.${property}`;
+        }
+        if (fieldType === FieldType.numeric || fieldType === FieldType.integer) {
+            jsonPath = `(${jsonPath})::numeric`;
+            value = Number(value);
+        }
+        else if (fieldType === FieldType.boolean) {
+            value = value.toLowerCase() === 'true';
+        }
+        else if (fieldType === FieldType.date) {
+            value = `'${value.replace(/^'(.*)'$/, '$1')}'`;
+        }
+        else {
+            value = value.replace(/^'(.*)'$/, '$1');
+        }
+        whereClauses.push(`${jsonPath} ${operator} ${paramIndex}`);
+        params.push(value);
+    }
+    const withParams = whereClauses.reduce((query, clause, index) => query.replace(`$${index + 1}`, typeof params[index] === 'string' ? `'${params[index]}'` : String(params[index])), whereClauses.join(' AND '));
+    return {
+        query: whereClauses.join(' AND '),
+        params,
+        withParams,
+    };
+}

package/tasks/functions/throw-task-error.d.ts

@@ -0,0 +1 @@
+export declare function throwTaskError(message: string, context?: string): void;

package/tasks/functions/throw-task-error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwTaskError = throwTaskError;
+const task_error_1 = require("../models/task-error");
+function throwTaskError(message, context) {
+    throw new task_error_1.TaskError(message, context);
+}

package/tasks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './decorators';
+export * from './functions/throw-task-error';

package/tasks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./functions/throw-task-error"), exports);

package/tasks/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './task-naming';
+export * from './task-object';
+export * from './task-post-intercept';
+export * from './task-runner';
+export * from './task-search-intercept';
+export * from './task-settings';

package/tasks/interfaces/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./task-naming"), exports);
+__exportStar(require("./task-object"), exports);
+__exportStar(require("./task-post-intercept"), exports);
+__exportStar(require("./task-runner"), exports);
+__exportStar(require("./task-search-intercept"), exports);
+__exportStar(require("./task-settings"), exports);