wapi-client 0.18.0-beta.3 → 0.18.0-beta.5

package/dist/db/consts.browser.js

@@ -1,415 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-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));
-
-// src/db/consts.ts
-import { createEnumFromTuple } from "../lib/ts-utils.browser.js";
-import { z } from "../lib/zod.browser.js";
-var MetadataSchema = z.record(
-  z.string(),
-  z.union([
-    z.string(),
-    z.boolean(),
-    z.number(),
-    z.null(),
-    z.undefined(),
-    z.lazy(() => MetadataSchema),
-    z.union([
-      z.string(),
-      z.boolean(),
-      z.number(),
-      z.null(),
-      z.undefined(),
-      z.lazy(() => MetadataSchema)
-    ]).array()
-  ])
-).nullable().describe("Custom key/value object");
-var DatetimeSchema = z.union([
-  z.string().datetime({ offset: true, local: true }),
-  z.string({
-    error: "must be a valid date-time string"
-  }).regex(/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/),
-  z.string().date()
-]);
-var DbTimezone = z.string().describe("Timezones allowed");
-var flagsSchema = z.object({
-  allow_timestamps: z.boolean().describe(
-    "Allow setting timestamps in transfer insert/update statements"
-  ),
-  production: z.boolean().describe("Is running in production mode?")
-}).partial().describe("System wide flags");
-var DbModelNameSchema = z.enum([
-  "Token",
-  "TransferGroup",
-  "TransferLog",
-  "Transfer",
-  "WalletTokenSetting",
-  "Wallet",
-  "WapiSetting"
-]);
-var DbModelNameEnum = createEnumFromTuple(DbModelNameSchema.options);
-var DbFilterOperatorEqualsSchema = z.enum(["="]);
-var DbFilterOperatorBasicSchema = z.enum([">=", "<=", "<", ">"]);
-var DbFilterOperatorStringSchema = z.enum(["like", "ilike"]);
-var DbFilterOperatorForNumbersSchema = z.enum([
-  ...DbFilterOperatorEqualsSchema.options,
-  ...DbFilterOperatorBasicSchema.options
-]).default("=");
-var DbFilterOperatorForStringsSchema = z.enum([
-  ...DbFilterOperatorEqualsSchema.options,
-  ...DbFilterOperatorBasicSchema.options,
-  ...DbFilterOperatorStringSchema.options
-]).default("=");
-var DbFilterOperatorAllSchema = z.enum([
-  ...DbFilterOperatorEqualsSchema.options,
-  ...DbFilterOperatorBasicSchema.options,
-  ...DbFilterOperatorStringSchema.options
-  // ...DbFilterOperatorInSchema.options,
-  // ...DbFilterOperatorNullSchema.options,
-]);
-var DbFilterAllowedValueSchema = z.union([
-  z.string(),
-  z.boolean(),
-  z.number()
-]);
-var DbFilterForeignSchema = z.object({
-  foreign: z.union([z.string(), z.number()])
-});
-var DbFilterIdentifierSchema = z.object({
-  identifier: z.union([z.string(), z.number()])
-});
-var DbFilterAllowedKeySchema = 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 = z.union([
-  z.string().array().min(1),
-  z.number().array().min(1)
-]);
-var DbFilterMetadataSchema = z.record(DbFilterAllowedKeySchema, DbFilterAllowedValueSchema).describe("Metadata filter for custom properties");
-var DbFilterFunctionBasicSchema = z.enum(["where", "orWhere"]);
-var DbFilterFunctionBasicEnum = createEnumFromTuple(
-  DbFilterFunctionBasicSchema.options
-);
-var DbFilterFunctionNullSchema = z.enum([
-  "whereNull",
-  "orWhereNull",
-  "whereNotNull",
-  "orWhereNotNull"
-]);
-var DbFilterFunctionNullEnum = createEnumFromTuple(
-  DbFilterFunctionNullSchema.options
-);
-var DbFilterFunctionInSchema = z.enum(["whereIn", "orWhereIn"]);
-var DbFilterFunctionInEnum = createEnumFromTuple(
-  DbFilterFunctionInSchema.options
-);
-var DbFilterFunctionMetadataBasicSchema = z.enum([
-  "whereMetadata",
-  "orWhereMetadata"
-]);
-var DbFilterFunctionMetadataBasicEnum = createEnumFromTuple(
-  DbFilterFunctionMetadataBasicSchema.options
-);
-var DbFilterFunctionMetadataNullSchema = z.enum([
-  "whereMetadataNull",
-  "orWhereMetadataNull",
-  "whereMetadataNotNull",
-  "orWhereMetadataNotNull"
-]);
-var DbFilterFunctionMetadataNullEnum = createEnumFromTuple(
-  DbFilterFunctionMetadataNullSchema.options
-);
-var DbFilterFunctionMetadataInSchema = z.enum([
-  "whereMetadataIn",
-  "orWhereMetadataIn"
-]);
-var DbFilterFunctionMetadataInEnum = createEnumFromTuple(
-  DbFilterFunctionMetadataInSchema.options
-);
-var DbFilterOperatorExtendedSchema = z.enum(["=", ">=", "<=", "<", ">", "ilike", "like"]).default("=");
-var DbFilterFunctionWherePrimitiveSchema = z.object({
-  function: DbFilterFunctionBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterAllowedValueSchema
-}).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereForeignAllowedSchema = z.union([
-  DbFilterAllowedValueSchema,
-  DbFilterForeignSchema
-]);
-var DbFilterFunctionWherePrimitiveForeignSchema = z.object({
-  function: DbFilterFunctionBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterFunctionWhereForeignAllowedSchema
-}).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereIdentifierAllowedSchema = z.union([
-  DbFilterAllowedValueSchema,
-  DbFilterIdentifierSchema
-]);
-var DbFilterFunctionWherePrimitiveIdentifierSchema = z.object({
-  function: DbFilterFunctionBasicSchema,
-  field: DbFilterAllowedKeySchema,
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: DbFilterFunctionWhereIdentifierAllowedSchema
-}).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereMetadataPrimitiveSchema = 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 = z.object({
-  metadata: DbFilterMetadataSchema.optional()
-}).catchall(DbFilterAllowedValueSchema);
-var DbFilterAllowedValueOrMetadataSchema = z.union([
-  DbFilterAllowedValueSchema,
-  DbFilterMetadataSchema
-]);
-var DbFilterFunctionWhereObjectSchema = z.object({
-  function: DbFilterFunctionBasicSchema,
-  value: DbFilterMetadataObjectSchema
-});
-var DbFilterFunctionWherePrimitiveObjectSchema = z.union([
-  DbFilterFunctionWherePrimitiveSchema,
-  DbFilterFunctionWhereObjectSchema
-]);
-var DbFilterFunctionWhereInSchema = z.object({
-  function: DbFilterFunctionInSchema,
-  field: DbFilterAllowedKeySchema,
-  value: DbFilterStringNumberArraySchema
-});
-var DbFilterFunctionWhereMetadataInSchema = z.object({
-  function: DbFilterFunctionMetadataInSchema,
-  field: DbFilterAllowedKeySchema,
-  value: DbFilterStringNumberArraySchema
-});
-var DbFilterFunctionWhereNullSchema = z.object({
-  function: DbFilterFunctionNullSchema,
-  field: DbFilterAllowedKeySchema
-}).describe(
-  "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull"
-);
-var DbFilterFunctionWhereMetadataNullSchema = z.object({
-  function: DbFilterFunctionMetadataNullSchema,
-  field: DbFilterAllowedKeySchema
-}).describe(
-  "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull for metadata"
-);
-var DbFilterMetadataFilteringSchema = z.discriminatedUnion(
-  "function",
-  [
-    DbFilterFunctionWhereMetadataPrimitiveSchema,
-    DbFilterFunctionWhereMetadataInSchema,
-    DbFilterFunctionWhereMetadataNullSchema
-  ]
-);
-var DbFilterFunctionWhereSchema = z.discriminatedUnion(
-  "function",
-  [
-    DbFilterFunctionWhereInSchema,
-    DbFilterFunctionWherePrimitiveSchema,
-    DbFilterFunctionWhereNullSchema
-  ]
-);
-var DbFilterSchema = z.union([
-  DbFilterFunctionWherePrimitiveObjectSchema,
-  DbFilterFunctionWhereInSchema,
-  DbFilterFunctionWhereNullSchema,
-  DbFilterMetadataFilteringSchema,
-  z.object({
-    function: DbFilterFunctionBasicSchema,
-    inner: z.lazy(() => DbFilterSchema.array())
-  })
-]);
-var DbFilterInnerSchema = z.object({
-  function: DbFilterFunctionBasicSchema,
-  inner: DbFilterSchema.array()
-});
-var DbFilterFunctionAllSchema = z.union([
-  DbFilterFunctionBasicSchema,
-  DbFilterFunctionInSchema,
-  DbFilterFunctionNullSchema,
-  DbFilterFunctionMetadataBasicSchema,
-  DbFilterFunctionMetadataInSchema,
-  DbFilterFunctionMetadataNullSchema
-]);
-var DbFilterShapeSchema = z.object({
-  function: DbFilterFunctionAllSchema,
-  field: DbFilterAllowedKeySchema.optional(),
-  operator: DbFilterOperatorExtendedSchema.optional(),
-  value: z.unknown().optional(),
-  inner: z.unknown().array().optional()
-});
-var DbFilterInnerGenericSchema = z.object({
-  function: DbFilterFunctionBasicSchema,
-  inner: 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 isMetadataDotFilterField(field) {
-  if (!(field == null ? void 0 : field.includes("."))) {
-    return false;
-  }
-  const [first] = field.split(".");
-  return first === "metadata" || first.endsWith("_metadata");
-}
-function getDbFilter(objectInputSchema, schema) {
-  const InSideSchema = schema.required();
-  const FieldsSchema = InSideSchema.keyof();
-  const ObjectFilterSchema = 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 (isMetadataDotFilterField(filterShapedData.field)) {
-      return validateSchema(
-        filterShapedData,
-        DbFilterFunctionWhereSchema,
-        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 z.record(DbFilterAllowedKeySchema, z.unknown()).check((ctx) => {
-    if (!ctx.value.function) {
-      validateSchema(ctx.value, objectInputSchema, ctx);
-      return;
-    }
-    refineFn(ctx.value, ctx);
-  });
-}
-export {
-  DatetimeSchema,
-  DbFilterAllowedKeySchema,
-  DbFilterAllowedValueOrMetadataSchema,
-  DbFilterAllowedValueSchema,
-  DbFilterForeignSchema,
-  DbFilterFunctionAllSchema,
-  DbFilterFunctionBasicEnum,
-  DbFilterFunctionBasicSchema,
-  DbFilterFunctionInEnum,
-  DbFilterFunctionInSchema,
-  DbFilterFunctionMetadataBasicEnum,
-  DbFilterFunctionMetadataBasicSchema,
-  DbFilterFunctionMetadataInEnum,
-  DbFilterFunctionMetadataInSchema,
-  DbFilterFunctionMetadataNullEnum,
-  DbFilterFunctionMetadataNullSchema,
-  DbFilterFunctionNullEnum,
-  DbFilterFunctionNullSchema,
-  DbFilterFunctionWhereForeignAllowedSchema,
-  DbFilterFunctionWhereIdentifierAllowedSchema,
-  DbFilterFunctionWhereInSchema,
-  DbFilterFunctionWhereMetadataInSchema,
-  DbFilterFunctionWhereMetadataNullSchema,
-  DbFilterFunctionWhereMetadataPrimitiveSchema,
-  DbFilterFunctionWhereNullSchema,
-  DbFilterFunctionWhereObjectSchema,
-  DbFilterFunctionWherePrimitiveForeignSchema,
-  DbFilterFunctionWherePrimitiveIdentifierSchema,
-  DbFilterFunctionWherePrimitiveObjectSchema,
-  DbFilterFunctionWherePrimitiveSchema,
-  DbFilterFunctionWhereSchema,
-  DbFilterIdentifierSchema,
-  DbFilterInnerGenericSchema,
-  DbFilterInnerSchema,
-  DbFilterMetadataFilteringSchema,
-  DbFilterMetadataObjectSchema,
-  DbFilterMetadataSchema,
-  DbFilterOperatorAllSchema,
-  DbFilterOperatorBasicSchema,
-  DbFilterOperatorEqualsSchema,
-  DbFilterOperatorExtendedSchema,
-  DbFilterOperatorForNumbersSchema,
-  DbFilterOperatorForStringsSchema,
-  DbFilterOperatorStringSchema,
-  DbFilterSchema,
-  DbFilterShapeSchema,
-  DbFilterStringNumberArraySchema,
-  DbModelNameEnum,
-  DbModelNameSchema,
-  DbTimezone,
-  MetadataSchema,
-  flagsSchema,
-  getDbFilter,
-  isMetadataDotFilterField
-};