wapi-client 0.7.2 → 0.8.2

package/dist/db/consts.schema.json

@@ -0,0 +1,483 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "Consts",
+  "description": "Enums and consts used by the system",
+  "definitions": {
+    "Flags": {
+      "$id": "Flags",
+      "$comment": "knex|manual",
+      "description": "Allowed filtering functions",
+      "type": "object",
+      "properties": {
+        "allow_timestamps": {
+          "description": "Allow setting timestamps in transfer insert/update statements",
+          "type": "boolean"
+        },
+        "production": {
+          "description": "Is running in production mode?",
+          "type": "boolean"
+        }
+      },
+      "$typescript": "{\"additionalProperties\":false}"
+    },
+    "DbFilterMetadata": {
+      "$id": "FilterMetadata",
+      "$comment": "knex|manual",
+      "description": "Metadata filtering object",
+      "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "format": "validkey"
+      },
+      "patternProperties": {
+        ".*": {
+          "type": ["string", "boolean", "number"]
+        }
+      }
+    },
+    "DbFilterFunctionWherePrimitive": {
+      "$id": "DbFilterFunctionWherePrimitive",
+      "$comment": "knex|manual",
+      "description": "Filtering for where and orWhere",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionBasic"
+        },
+        "field": {
+          "type": "string"
+        },
+        "operator": {
+          "$ref": "#/definitions/DbFilterOperatorExtended"
+        },
+        "value": {
+          "type": ["string", "number", "boolean"]
+        }
+      },
+      "required": ["function", "field", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionWherePrimitiveForeign": {
+      "$id": "DbFilterFunctionWherePrimitiveForeign",
+      "$comment": "knex|manual",
+      "description": "Filtering for where and orWhere",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionBasic"
+        },
+        "field": {
+          "type": "string"
+        },
+        "operator": {
+          "$ref": "#/definitions/DbFilterOperatorExtended"
+        },
+        "value": {
+          "anyOf": [
+            {
+              "type": ["string", "number", "boolean"]
+            },
+            {
+              "type": "object",
+              "properties": {
+                "foreign": {
+                  "type": ["string", "number"]
+                }
+              },
+              "required": ["foreign"],
+              "$typescript": "{\"additionalProperties\": false}"
+            }
+          ]
+        }
+      },
+      "required": ["function", "field", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionWherePrimitiveIdentifier": {
+      "$id": "DbFilterFunctionWherePrimitiveIdentifier",
+      "$comment": "knex|manual",
+      "description": "Filtering for where and orWhere",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionBasic"
+        },
+        "field": {
+          "type": "string"
+        },
+        "operator": {
+          "$ref": "#/definitions/DbFilterOperatorExtended"
+        },
+        "value": {
+          "anyOf": [
+            {
+              "type": ["string", "number", "boolean"]
+            },
+            {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": ["string", "number"]
+                }
+              },
+              "required": ["identifier"],
+              "$typescript": "{\"additionalProperties\": false}"
+            }
+          ]
+        }
+      },
+      "required": ["function", "field", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionWhereMetadataPrimitive": {
+      "$id": "DbFilterFunctionWhereMetadataPrimitive",
+      "$comment": "knex|manual",
+      "description": "Filtering for where and orWhere",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionMetadataBasic"
+        },
+        "field": {
+          "type": "string"
+        },
+        "operator": {
+          "$ref": "#/definitions/DbFilterOperatorExtended"
+        },
+        "value": {
+          "type": ["string", "number", "boolean"]
+        }
+      },
+      "required": ["function", "field", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionMetadataBasic": {
+      "$id": "DbFilterFunctionMetadataBasic",
+      "$comment": "knex|manual",
+      "type": "string",
+      "enum": ["whereMetadata", "orWhereMetadata"]
+    },
+    "DbFilterFunctionWhereObject": {
+      "$id": "DbFilterFunctionWhereObject",
+      "$comment": "knex|manual",
+      "description": "Filtering for where and orWhere",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionBasic"
+        },
+        "value": {
+          "type": "object",
+          "properties": {
+            "metadata": {
+              "$ref": "#/definitions/DbFilterMetadata"
+            }
+          }
+        }
+      },
+      "required": ["function", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionBasic": {
+      "$id": "DbFilterFunctionBasic",
+      "$comment": "knex|manual",
+      "type": "string",
+      "enum": ["where", "orWhere"]
+    },
+    "DbFilterFunctionWhereIns": {
+      "$id": "DbFilterFunctionWhereIns",
+      "$comment": "knex|manual",
+      "description": "Filtering for whereIn and orWhereIn",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionIn"
+        },
+        "field": {
+          "type": "string"
+        },
+        "value": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "minItems": 1
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "number"
+              },
+              "minItems": 1
+            }
+          ]
+        }
+      },
+      "required": ["function", "field", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionIn": {
+      "$id": "DbFilterFunctionIn",
+      "$comment": "knex|manual",
+      "type": "string",
+      "enum": ["whereIn", "orWhereIn"]
+    },
+    "DbFilterFunctionWhereMetadataIns": {
+      "$id": "DbFilterFunctionWhereMetadataIns",
+      "$comment": "knex|manual",
+      "description": "Filtering for whereIn and orWhereIn for metadata",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionMetadataIn"
+        },
+        "field": {
+          "type": "string"
+        },
+        "value": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "minItems": 1
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "number"
+              },
+              "minItems": 1
+            }
+          ]
+        }
+      },
+      "required": ["function", "field", "value"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionMetadataIn": {
+      "$id": "DbFilterFunctionMetadataIn",
+      "$comment": "knex|manual",
+      "type": "string",
+      "enum": ["whereMetadataIn", "orWhereMetadataIn"]
+    },
+    "DbFilterFunctionWhereMetadataNulls": {
+      "$id": "DbFilterFunctionWhereMetadataNulls",
+      "$comment": "knex|manual",
+      "description": "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull for metadata",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionMetadataNull"
+        },
+        "field": {
+          "type": "string"
+        }
+      },
+      "required": ["function", "field"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionMetadataNull": {
+      "$id": "DbFilterFunctionMetadataNull",
+      "$comment": "knex|manual",
+      "type": "string",
+      "enum": [
+        "whereMetadataNull",
+        "orWhereMetadataNull",
+        "whereMetadataNotNull",
+        "orWhereMetadataNotNull"
+      ]
+    },
+    "DbFilterFunctionWhereNulls": {
+      "$id": "DbFilterFunctionWhereNulls",
+      "$comment": "knex|manual",
+      "description": "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionNull"
+        },
+        "field": {
+          "type": "string"
+        }
+      },
+      "required": ["function", "field"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "DbFilterFunctionNull": {
+      "$id": "DbFilterFunctionNull",
+      "$comment": "knex|manual",
+      "type": "string",
+      "enum": ["whereNull", "orWhereNull", "whereNotNull", "orWhereNotNull"]
+    },
+    "DbFilterOperator": {
+      "$id": "DbFilterOperator",
+      "$comment": "knex|manual",
+      "description": "Allowed filtering operators, ignored when value is not primitive",
+      "type": "string",
+      "enum": ["=", ">=", "<=", "<", ">"],
+      "default": "="
+    },
+    "DbFilterOperatorString": {
+      "$id": "DbFilterOperatorString",
+      "$comment": "knex|manual",
+      "description": "Allowed filtering operators for strings",
+      "type": "string",
+      "enum": ["like", "ilike"]
+    },
+    "DbFilterOperatorExtended": {
+      "$id": "DbFilterOperatorExtended",
+      "$comment": "knex|manual",
+      "description": "Allowed filtering operators, ignored when value is not primitive",
+      "type": "string",
+      "enum": ["=", ">=", "<=", "<", ">", "like", "ilike"],
+      "default": "="
+    },
+    "DbFilter": {
+      "$id": "DbFilter",
+      "$comment": "knex|manual",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/DbFilterMetadata"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereInner"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWherePrimitive"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWherePrimitiveForeign"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWherePrimitiveIdentifier"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereMetadataPrimitive"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereObject"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereIns"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereMetadataIns"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereMetadataNulls"
+        },
+        {
+          "$ref": "#/definitions/DbFilterFunctionWhereNulls"
+        }
+      ]
+    },
+    "DbFilterFunctionWhereInner": {
+      "$id": "DbFilterFunctionWhereInner",
+      "$comment": "knex|manual",
+      "description": "Filtering for where and orWhere",
+      "type": "object",
+      "properties": {
+        "function": {
+          "$ref": "#/definitions/DbFilterFunctionBasic"
+        },
+        "inner": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/DbFilter"
+          }
+        }
+      },
+      "required": ["function", "inner"],
+      "$typescript": "{\"additionalProperties\": false}"
+    },
+    "TokenType": {
+      "$id": "TokenType",
+      "$comment": "model",
+      "description": "DB type values for TokenType",
+      "type": "string",
+      "enum": ["value", "share", "group", "contract"]
+    },
+    "TokenStatus": {
+      "$id": "TokenStatus",
+      "$comment": "model",
+      "description": "DB type values for TokenStatus",
+      "type": "string",
+      "enum": ["active", "dw-only", "disabled"]
+    },
+    "TransferGroupStatus": {
+      "$id": "TransferGroupStatus",
+      "$comment": "model",
+      "description": "DB type values for TransferGroupStatus",
+      "type": "string",
+      "enum": ["open", "closed"]
+    },
+    "TransferStatus": {
+      "$id": "TransferStatus",
+      "$comment": "model",
+      "description": "DB type values for TransferStatus",
+      "type": "string",
+      "enum": ["pending", "finished", "cancelled"]
+    },
+    "TransferStatusInput": {
+      "$id": "TransferStatusInput",
+      "$comment": "model",
+      "description": "DB type input values for TransferStatus",
+      "type": "string",
+      "enum": ["pending", "finished"]
+    },
+    "TransferGroupType": {
+      "$id": "TransferGroupType",
+      "$comment": "model",
+      "description": "DB type values for TransferGroupType",
+      "type": "string",
+      "enum": ["regular", "exchange", "distribution"]
+    },
+    "TransferType": {
+      "$id": "TransferType",
+      "$comment": "model",
+      "description": "DB type values for TransferType",
+      "type": "string",
+      "enum": ["transfer", "deposit", "withdrawal"]
+    },
+    "WalletType": {
+      "$id": "WalletType",
+      "$comment": "model",
+      "description": "DB type values for WalletType",
+      "type": "string",
+      "enum": ["token", "house", "regular"]
+    },
+    "WalletStatus": {
+      "$id": "WalletStatus",
+      "$comment": "model",
+      "description": "DB type values for WalletStatus",
+      "type": "string",
+      "enum": ["active", "disabled"]
+    },
+    "WapiSettingType": {
+      "$id": "WapiSettingType",
+      "$comment": "model",
+      "description": "DB type values for WapiSettingType",
+      "type": "string",
+      "enum": ["flag", "setting"]
+    },
+    "DbModelName": {
+      "$id": "DbModelName",
+      "$comment": "model",
+      "description": "DB Model Names",
+      "type": "string",
+      "enum": [
+        "Token",
+        "TransferGroup",
+        "TransferLog",
+        "Transfer",
+        "WalletTokenSetting",
+        "Wallet",
+        "WapiSetting"
+      ]
+    }
+  }
+}

package/dist/db/index.browser.cjs

@@ -0,0 +1,84 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/db/index.ts
+var db_exports = {};
+__export(db_exports, {
+  ConstsSchema: () => import_consts_schema.default,
+  DbFilterFunctionBasicEnum: () => import_consts.DbFilterFunctionBasicEnum,
+  DbFilterFunctionInEnum: () => import_consts.DbFilterFunctionInEnum,
+  DbFilterFunctionMetadataBasicEnum: () => import_consts.DbFilterFunctionMetadataBasicEnum,
+  DbFilterFunctionMetadataInEnum: () => import_consts.DbFilterFunctionMetadataInEnum,
+  DbFilterFunctionMetadataNullEnum: () => import_consts.DbFilterFunctionMetadataNullEnum,
+  DbFilterFunctionNullEnum: () => import_consts.DbFilterFunctionNullEnum,
+  DbFilterOperatorEnum: () => import_consts.DbFilterOperatorEnum,
+  DbFilterOperatorExtendedEnum: () => import_consts.DbFilterOperatorExtendedEnum,
+  DbFilterOperatorStringEnum: () => import_consts.DbFilterOperatorStringEnum,
+  DbModelNameEnum: () => import_consts.DbModelNameEnum,
+  TokenStatusEnum: () => import_consts.TokenStatusEnum,
+  TokenTableInputSchema: () => import_token_schema_input.default,
+  TokenTableSchema: () => import_token_schema.default,
+  TokenTypeEnum: () => import_consts.TokenTypeEnum,
+  TransferGroupStatusEnum: () => import_consts.TransferGroupStatusEnum,
+  TransferGroupTableInputSchema: () => import_transfer_group_schema_input.default,
+  TransferGroupTableSchema: () => import_transfer_group_schema.default,
+  TransferGroupTypeEnum: () => import_consts.TransferGroupTypeEnum,
+  TransferLogTableInputSchema: () => import_transfer_log_schema_input.default,
+  TransferLogTableSchema: () => import_transfer_log_schema.default,
+  TransferStatusEnum: () => import_consts.TransferStatusEnum,
+  TransferStatusInputEnum: () => import_consts.TransferStatusInputEnum,
+  TransferTableInputSchema: () => import_transfer_schema_input.default,
+  TransferTableSchema: () => import_transfer_schema.default,
+  TransferTypeEnum: () => import_consts.TransferTypeEnum,
+  WalletStatusEnum: () => import_consts.WalletStatusEnum,
+  WalletTableInputSchema: () => import_wallet_schema_input.default,
+  WalletTableSchema: () => import_wallet_schema.default,
+  WalletTokenSettingTableInputSchema: () => import_wallet_token_setting_schema_input.default,
+  WalletTokenSettingTableSchema: () => import_wallet_token_setting_schema.default,
+  WalletTypeEnum: () => import_consts.WalletTypeEnum,
+  WapiSettingTableInputSchema: () => import_wapi_setting_schema_input.default,
+  WapiSettingTableSchema: () => import_wapi_setting_schema.default,
+  WapiSettingTypeEnum: () => import_consts.WapiSettingTypeEnum
+});
+module.exports = __toCommonJS(db_exports);
+var import_consts = require('./consts.enums.cjs');
+var import_consts_schema = __toESM(require('./consts.schema.json'), 1);
+var import_token_schema_input = __toESM(require('./token/token.schema.input.json'), 1);
+var import_token_schema = __toESM(require('./token/token.schema.json'), 1);
+var import_transfer_schema_input = __toESM(require('./transfer/transfer.schema.input.json'), 1);
+var import_transfer_schema = __toESM(require('./transfer/transfer.schema.json'), 1);
+var import_transfer_group_schema_input = __toESM(require('./transfer-group/transfer-group.schema.input.json'), 1);
+var import_transfer_group_schema = __toESM(require('./transfer-group/transfer-group.schema.json'), 1);
+var import_transfer_log_schema_input = __toESM(require('./transfer-log/transfer-log.schema.input.json'), 1);
+var import_transfer_log_schema = __toESM(require('./transfer-log/transfer-log.schema.json'), 1);
+var import_wallet_schema_input = __toESM(require('./wallet/wallet.schema.input.json'), 1);
+var import_wallet_schema = __toESM(require('./wallet/wallet.schema.json'), 1);
+var import_wallet_token_setting_schema_input = __toESM(require('./wallet-token-setting/wallet-token-setting.schema.input.json'), 1);
+var import_wallet_token_setting_schema = __toESM(require('./wallet-token-setting/wallet-token-setting.schema.json'), 1);
+var import_wapi_setting_schema_input = __toESM(require('./wapi-setting/wapi-setting.schema.input.json'), 1);
+var import_wapi_setting_schema = __toESM(require('./wapi-setting/wapi-setting.schema.json'), 1);

package/dist/db/index.browser.js

@@ -0,0 +1,75 @@
+// src/db/index.ts
+import {
+  DbFilterFunctionMetadataBasicEnum,
+  DbFilterFunctionBasicEnum,
+  DbFilterFunctionInEnum,
+  DbFilterFunctionMetadataInEnum,
+  DbFilterFunctionMetadataNullEnum,
+  DbFilterFunctionNullEnum,
+  DbFilterOperatorEnum,
+  DbFilterOperatorStringEnum,
+  DbFilterOperatorExtendedEnum,
+  TokenTypeEnum,
+  TokenStatusEnum,
+  TransferGroupStatusEnum,
+  TransferStatusEnum,
+  TransferStatusInputEnum,
+  TransferGroupTypeEnum,
+  TransferTypeEnum,
+  WalletTypeEnum,
+  WalletStatusEnum,
+  WapiSettingTypeEnum,
+  DbModelNameEnum
+} from "./consts.enums.browser.js";
+import ConstsSchema from "./consts.schema.json";
+import TokenTableInputSchema from "./token/token.schema.input.json";
+import TokenTableSchema from "./token/token.schema.json";
+import TransferTableInputSchema from "./transfer/transfer.schema.input.json";
+import TransferTableSchema from "./transfer/transfer.schema.json";
+import TransferGroupTableInputSchema from "./transfer-group/transfer-group.schema.input.json";
+import TransferGroupTableSchema from "./transfer-group/transfer-group.schema.json";
+import TransferLogTableInputSchema from "./transfer-log/transfer-log.schema.input.json";
+import TransferLogTableSchema from "./transfer-log/transfer-log.schema.json";
+import WalletTableInputSchema from "./wallet/wallet.schema.input.json";
+import WalletTableSchema from "./wallet/wallet.schema.json";
+import WalletTokenSettingTableInputSchema from "./wallet-token-setting/wallet-token-setting.schema.input.json";
+import WalletTokenSettingTableSchema from "./wallet-token-setting/wallet-token-setting.schema.json";
+import WapiSettingTableInputSchema from "./wapi-setting/wapi-setting.schema.input.json";
+import WapiSettingTableSchema from "./wapi-setting/wapi-setting.schema.json";
+export {
+  ConstsSchema,
+  DbFilterFunctionBasicEnum,
+  DbFilterFunctionInEnum,
+  DbFilterFunctionMetadataBasicEnum,
+  DbFilterFunctionMetadataInEnum,
+  DbFilterFunctionMetadataNullEnum,
+  DbFilterFunctionNullEnum,
+  DbFilterOperatorEnum,
+  DbFilterOperatorExtendedEnum,
+  DbFilterOperatorStringEnum,
+  DbModelNameEnum,
+  TokenStatusEnum,
+  TokenTableInputSchema,
+  TokenTableSchema,
+  TokenTypeEnum,
+  TransferGroupStatusEnum,
+  TransferGroupTableInputSchema,
+  TransferGroupTableSchema,
+  TransferGroupTypeEnum,
+  TransferLogTableInputSchema,
+  TransferLogTableSchema,
+  TransferStatusEnum,
+  TransferStatusInputEnum,
+  TransferTableInputSchema,
+  TransferTableSchema,
+  TransferTypeEnum,
+  WalletStatusEnum,
+  WalletTableInputSchema,
+  WalletTableSchema,
+  WalletTokenSettingTableInputSchema,
+  WalletTokenSettingTableSchema,
+  WalletTypeEnum,
+  WapiSettingTableInputSchema,
+  WapiSettingTableSchema,
+  WapiSettingTypeEnum
+};