wapi-client 0.17.18 → 0.18.0-beta.2

package/dist/db/consts.browser.cjs

@@ -1,409 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/db/consts.ts
-var consts_exports = {};
-__export(consts_exports, {
-  DatetimeSchema: () => DatetimeSchema,
-  DbFilterAllowedKeySchema: () => DbFilterAllowedKeySchema,
-  DbFilterAllowedValueOrMetadataSchema: () => DbFilterAllowedValueOrMetadataSchema,
-  DbFilterAllowedValueSchema: () => DbFilterAllowedValueSchema,
-  DbFilterForeignSchema: () => DbFilterForeignSchema,
-  DbFilterFunctionAllSchema: () => DbFilterFunctionAllSchema,
-  DbFilterFunctionBasicEnum: () => DbFilterFunctionBasicEnum,
-  DbFilterFunctionBasicSchema: () => DbFilterFunctionBasicSchema,
-  DbFilterFunctionInEnum: () => DbFilterFunctionInEnum,
-  DbFilterFunctionInSchema: () => DbFilterFunctionInSchema,
-  DbFilterFunctionMetadataBasicEnum: () => DbFilterFunctionMetadataBasicEnum,
-  DbFilterFunctionMetadataBasicSchema: () => DbFilterFunctionMetadataBasicSchema,
-  DbFilterFunctionMetadataInEnum: () => DbFilterFunctionMetadataInEnum,
-  DbFilterFunctionMetadataInSchema: () => DbFilterFunctionMetadataInSchema,
-  DbFilterFunctionMetadataNullEnum: () => DbFilterFunctionMetadataNullEnum,
-  DbFilterFunctionMetadataNullSchema: () => DbFilterFunctionMetadataNullSchema,
-  DbFilterFunctionNullEnum: () => DbFilterFunctionNullEnum,
-  DbFilterFunctionNullSchema: () => DbFilterFunctionNullSchema,
-  DbFilterFunctionWhereForeignAllowedSchema: () => DbFilterFunctionWhereForeignAllowedSchema,
-  DbFilterFunctionWhereIdentifierAllowedSchema: () => DbFilterFunctionWhereIdentifierAllowedSchema,
-  DbFilterFunctionWhereInSchema: () => DbFilterFunctionWhereInSchema,
-  DbFilterFunctionWhereMetadataInSchema: () => DbFilterFunctionWhereMetadataInSchema,
-  DbFilterFunctionWhereMetadataNullSchema: () => DbFilterFunctionWhereMetadataNullSchema,
-  DbFilterFunctionWhereMetadataPrimitiveSchema: () => DbFilterFunctionWhereMetadataPrimitiveSchema,
-  DbFilterFunctionWhereNullSchema: () => DbFilterFunctionWhereNullSchema,
-  DbFilterFunctionWhereObjectSchema: () => DbFilterFunctionWhereObjectSchema,
-  DbFilterFunctionWherePrimitiveForeignSchema: () => DbFilterFunctionWherePrimitiveForeignSchema,
-  DbFilterFunctionWherePrimitiveIdentifierSchema: () => DbFilterFunctionWherePrimitiveIdentifierSchema,
-  DbFilterFunctionWherePrimitiveObjectSchema: () => DbFilterFunctionWherePrimitiveObjectSchema,
-  DbFilterFunctionWherePrimitiveSchema: () => DbFilterFunctionWherePrimitiveSchema,
-  DbFilterIdentifierSchema: () => DbFilterIdentifierSchema,
-  DbFilterInnerGenericSchema: () => DbFilterInnerGenericSchema,
-  DbFilterInnerSchema: () => DbFilterInnerSchema,
-  DbFilterMetadataFilteringSchema: () => DbFilterMetadataFilteringSchema,
-  DbFilterMetadataObjectSchema: () => DbFilterMetadataObjectSchema,
-  DbFilterMetadataSchema: () => DbFilterMetadataSchema,
-  DbFilterOperatorAllSchema: () => DbFilterOperatorAllSchema,
-  DbFilterOperatorBasicSchema: () => DbFilterOperatorBasicSchema,
-  DbFilterOperatorEqualsSchema: () => DbFilterOperatorEqualsSchema,
-  DbFilterOperatorExtendedSchema: () => DbFilterOperatorExtendedSchema,
-  DbFilterOperatorForNumbersSchema: () => DbFilterOperatorForNumbersSchema,
-  DbFilterOperatorForStringsSchema: () => DbFilterOperatorForStringsSchema,
-  DbFilterOperatorStringSchema: () => DbFilterOperatorStringSchema,
-  DbFilterSchema: () => DbFilterSchema,
-  DbFilterShapeSchema: () => DbFilterShapeSchema,
-  DbFilterStringNumberArraySchema: () => DbFilterStringNumberArraySchema,
-  DbModelNameEnum: () => DbModelNameEnum,
-  DbModelNameSchema: () => DbModelNameSchema,
-  DbTimezone: () => DbTimezone,
-  MetadataSchema: () => MetadataSchema,
-  flagsSchema: () => flagsSchema,
-  getDbFilter: () => getDbFilter
-});
-module.exports = __toCommonJS(consts_exports);
-var import_ts_utils = require("../lib/ts-utils.browser.cjs");
-var import_zod = require("zod");
-var MetadataSchema = import_zod.z.record(
-  import_zod.z.string(),
-  import_zod.z.union([
-    import_zod.z.string(),
-    import_zod.z.boolean(),
-    import_zod.z.number(),
-    import_zod.z.null(),
-    import_zod.z.undefined(),
-    import_zod.z.lazy(() => MetadataSchema),
-    import_zod.z.union([
-      import_zod.z.string(),
-      import_zod.z.boolean(),
-      import_zod.z.number(),
-      import_zod.z.null(),
-      import_zod.z.undefined(),
-      import_zod.z.lazy(() => MetadataSchema)
-    ]).array()
-  ])
-).nullable().describe("Custom key/value object");
-var DatetimeSchema = import_zod.z.union([
-  import_zod.z.string().datetime({ offset: true, local: true }),
-  import_zod.z.string({
-    error: "must be a valid date-time string"
-  }).regex(/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/),
-  import_zod.z.string().date()
-]);
-var DbTimezone = import_zod.z.string().describe("Timezones allowed");
-var flagsSchema = import_zod.z.object({
-  allow_timestamps: import_zod.z.boolean().describe(
-    "Allow setting timestamps in transfer insert/update statements"
-  ),
-  production: import_zod.z.boolean().describe("Is running in production mode?")
-}).partial().describe("System wide flags");
-var DbModelNameSchema = import_zod.z.enum([
-  "Token",
-  "TransferGroup",
-  "TransferLog",
-  "Transfer",
-  "WalletTokenSetting",
-  "Wallet",
-  "WapiSetting"
-]);
-var DbModelNameEnum = (0, import_ts_utils.createEnumFromTuple)(DbModelNameSchema.options);
-var DbFilterOperatorEqualsSchema = import_zod.z.enum(["="]);
-var DbFilterOperatorBasicSchema = import_zod.z.enum([">=", "<=", "<", ">"]);
-var DbFilterOperatorStringSchema = import_zod.z.enum(["like", "ilike"]);
-var DbFilterOperatorForNumbersSchema = import_zod.z.enum([
-  ...DbFilterOperatorEqualsSchema.options,
-  ...DbFilterOperatorBasicSchema.options
-]).default("=");
-var DbFilterOperatorForStringsSchema = import_zod.z.enum([
-  ...DbFilterOperatorEqualsSchema.options,
-  ...DbFilterOperatorBasicSchema.options,
-  ...DbFilterOperatorStringSchema.options
-]).default("=");
-var DbFilterOperatorAllSchema = import_zod.z.enum([
-  ...DbFilterOperatorEqualsSchema.options,
-  ...DbFilterOperatorBasicSchema.options,
-  ...DbFilterOperatorStringSchema.options
-  // ...DbFilterOperatorInSchema.options,
-  // ...DbFilterOperatorNullSchema.options,
-]);
-var DbFilterAllowedValueSchema = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.boolean(),
-  import_zod.z.number()
-]);
-var DbFilterForeignSchema = import_zod.z.object({
-  foreign: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
-});
-var DbFilterIdentifierSchema = import_zod.z.object({
-  identifier: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
-});
-var DbFilterAllowedKeySchema = import_zod.z.string().regex(
-  /^(?!.*\.\.)[a-zA-Z_][a-zA-Z0-9_.-]*[a-zA-Z0-9_-]$/,
-  "Key is limited to [a-zA-Z0-9_-] and cant start with a number"
-);
-var DbFilterStringNumberArraySchema = import_zod.z.union([
-  import_zod.z.string().array().min(1),
-  import_zod.z.number().array().min(1)
-]);
-var DbFilterMetadataSchema = import_zod.z.record(DbFilterAllowedKeySchema, DbFilterAllowedValueSchema).describe("Metadata filter for custom properties");
-var DbFilterFunctionBasicSchema = import_zod.z.enum(["where", "orWhere"]);
-var DbFilterFunctionBasicEnum = (0, import_ts_utils.createEnumFromTuple)(
-  DbFilterFunctionBasicSchema.options
-);
-var DbFilterFunctionNullSchema = import_zod.z.enum([
-  "whereNull",
-  "orWhereNull",
-  "whereNotNull",
-  "orWhereNotNull"
-]);
-var DbFilterFunctionNullEnum = (0, import_ts_utils.createEnumFromTuple)(
-  DbFilterFunctionNullSchema.options
-);
-var DbFilterFunctionInSchema = import_zod.z.enum(["whereIn", "orWhereIn"]);
-var DbFilterFunctionInEnum = (0, import_ts_utils.createEnumFromTuple)(
-  DbFilterFunctionInSchema.options
-);
-var DbFilterFunctionMetadataBasicSchema = import_zod.z.enum([
-  "whereMetadata",
-  "orWhereMetadata"
-]);
-var DbFilterFunctionMetadataBasicEnum = (0, import_ts_utils.createEnumFromTuple)(
-  DbFilterFunctionMetadataBasicSchema.options
-);
-var DbFilterFunctionMetadataNullSchema = import_zod.z.enum([
-  "whereMetadataNull",
-  "orWhereMetadataNull",
-  "whereMetadataNotNull",
-  "orWhereMetadataNotNull"
-]);
-var DbFilterFunctionMetadataNullEnum = (0, import_ts_utils.createEnumFromTuple)(
-  DbFilterFunctionMetadataNullSchema.options
-);
-var DbFilterFunctionMetadataInSchema = import_zod.z.enum([
-  "whereMetadataIn",
-  "orWhereMetadataIn"
-]);
-var DbFilterFunctionMetadataInEnum = (0, import_ts_utils.createEnumFromTuple)(
-  DbFilterFunctionMetadataInSchema.options
-);
-var DbFilterOperatorExtendedSchema = import_zod.z.enum(["=", ">=", "<=", "<", ">", "ilike", "like"]).default("=");
-var DbFilterFunctionWherePrimitiveSchema = import_zod.z.object({
-  function: DbFilterFunctionBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterAllowedValueSchema
-}).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereForeignAllowedSchema = import_zod.z.union([
-  DbFilterAllowedValueSchema,
-  DbFilterForeignSchema
-]);
-var DbFilterFunctionWherePrimitiveForeignSchema = import_zod.z.object({
-  function: DbFilterFunctionBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterFunctionWhereForeignAllowedSchema
-}).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereIdentifierAllowedSchema = import_zod.z.union([
-  DbFilterAllowedValueSchema,
-  DbFilterIdentifierSchema
-]);
-var DbFilterFunctionWherePrimitiveIdentifierSchema = import_zod.z.object({
-  function: DbFilterFunctionBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterFunctionWhereIdentifierAllowedSchema
-}).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereMetadataPrimitiveSchema = import_zod.z.object({
-  function: DbFilterFunctionMetadataBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterAllowedValueSchema
-}).required({
-  function: true,
-  field: true,
-  value: true
-}).describe("Filtering for where and orWhere");
-var DbFilterMetadataObjectSchema = import_zod.z.object({
-  metadata: DbFilterMetadataSchema.optional()
-}).catchall(DbFilterAllowedValueSchema);
-var DbFilterAllowedValueOrMetadataSchema = import_zod.z.union([
-  DbFilterAllowedValueSchema,
-  DbFilterMetadataSchema
-]);
-var DbFilterFunctionWhereObjectSchema = import_zod.z.object({
-  function: DbFilterFunctionBasicSchema,
-  value: DbFilterMetadataObjectSchema
-});
-var DbFilterFunctionWherePrimitiveObjectSchema = import_zod.z.union([
-  DbFilterFunctionWherePrimitiveSchema,
-  DbFilterFunctionWhereObjectSchema
-]);
-var DbFilterFunctionWhereInSchema = import_zod.z.object({
-  function: DbFilterFunctionInSchema,
-  field: DbFilterAllowedKeySchema,
-  value: DbFilterStringNumberArraySchema
-});
-var DbFilterFunctionWhereMetadataInSchema = import_zod.z.object({
-  function: DbFilterFunctionMetadataInSchema,
-  field: DbFilterAllowedKeySchema,
-  value: DbFilterStringNumberArraySchema
-});
-var DbFilterFunctionWhereNullSchema = import_zod.z.object({
-  function: DbFilterFunctionNullSchema,
-  field: DbFilterAllowedKeySchema
-}).describe(
-  "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull"
-);
-var DbFilterFunctionWhereMetadataNullSchema = import_zod.z.object({
-  function: DbFilterFunctionMetadataNullSchema,
-  field: DbFilterAllowedKeySchema
-}).describe(
-  "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull for metadata"
-);
-var DbFilterMetadataFilteringSchema = import_zod.z.discriminatedUnion(
-  "function",
-  [
-    DbFilterFunctionWhereMetadataPrimitiveSchema,
-    DbFilterFunctionWhereMetadataInSchema,
-    DbFilterFunctionWhereMetadataNullSchema
-  ]
-);
-var DbFilterSchema = import_zod.z.union([
-  DbFilterFunctionWherePrimitiveObjectSchema,
-  DbFilterFunctionWhereInSchema,
-  DbFilterFunctionWhereNullSchema,
-  DbFilterMetadataFilteringSchema,
-  import_zod.z.object({
-    function: DbFilterFunctionBasicSchema,
-    inner: import_zod.z.lazy(() => DbFilterSchema.array())
-  })
-]);
-var DbFilterInnerSchema = import_zod.z.object({
-  function: DbFilterFunctionBasicSchema,
-  inner: DbFilterSchema.array()
-});
-var DbFilterFunctionAllSchema = import_zod.z.union([
-  DbFilterFunctionBasicSchema,
-  DbFilterFunctionInSchema,
-  DbFilterFunctionNullSchema,
-  DbFilterFunctionMetadataBasicSchema,
-  DbFilterFunctionMetadataInSchema,
-  DbFilterFunctionMetadataNullSchema
-]);
-var DbFilterShapeSchema = import_zod.z.object({
-  function: DbFilterFunctionAllSchema,
-  field: DbFilterAllowedKeySchema.optional(),
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: import_zod.z.unknown().optional(),
-  inner: import_zod.z.unknown().array().optional()
-});
-var DbFilterInnerGenericSchema = import_zod.z.object({
-  function: DbFilterFunctionBasicSchema,
-  inner: import_zod.z.unknown().array()
-});
-function validateSchema(data, schema, ctx) {
-  const validation = schema.safeParse(data);
-  if (!validation.success) {
-    validation.error.issues.forEach((err) => {
-      ctx.issues.push(__spreadProps(__spreadValues({}, err), {
-        code: "custom",
-        input: ctx.value,
-        message: "complex_error:" + err.message
-      }));
-    });
-  }
-  return validation.success;
-}
-function getDbFilter(objectInputSchema, schema) {
-  const InSideSchema = schema.required();
-  const FieldsSchema = InSideSchema.keyof();
-  const ObjectFilterSchema = import_zod.z.object({
-    function: DbFilterFunctionBasicSchema,
-    value: objectInputSchema
-  });
-  const refineFn = ((data, ctx) => {
-    if (!validateSchema(data, DbFilterShapeSchema, ctx)) {
-      return false;
-    }
-    const filterShapedData = data;
-    if (filterShapedData.inner) {
-      if (!validateSchema(filterShapedData, DbFilterInnerGenericSchema, ctx)) {
-        return false;
-      }
-      return !filterShapedData.inner.some((innerData) => {
-        const res = refineFn(innerData, ctx);
-        if (res === false) {
-          return true;
-        }
-      });
-    }
-    if (!filterShapedData.field) {
-      return validateSchema(filterShapedData, ObjectFilterSchema, ctx);
-    }
-    if (filterShapedData.function.toLowerCase().includes("metadata")) {
-      return validateSchema(
-        filterShapedData,
-        DbFilterMetadataFilteringSchema,
-        ctx
-      );
-    }
-    if (!validateSchema(filterShapedData.field, FieldsSchema, ctx) || !InSideSchema.shape[filterShapedData.field]) {
-      return false;
-    }
-    if (filterShapedData.function.toLowerCase().includes("null")) {
-      return true;
-    }
-    if ("enum" in InSideSchema.shape[filterShapedData.field]) {
-      if (!Array.isArray(filterShapedData.value) && !validateSchema(
-        filterShapedData.value,
-        InSideSchema.shape[filterShapedData.field],
-        ctx
-      )) {
-        return false;
-      }
-      if (Array.isArray(filterShapedData.value) && !validateSchema(
-        filterShapedData.value,
-        InSideSchema.shape[filterShapedData.field].array(),
-        ctx
-      )) {
-        return false;
-      }
-    }
-  });
-  return import_zod.z.record(DbFilterAllowedKeySchema, import_zod.z.unknown()).check((ctx) => {
-    if (!ctx.value.function) {
-      validateSchema(ctx.value, objectInputSchema, ctx);
-      return;
-    }
-    refineFn(ctx.value, ctx);
-  });
-}