wapi-client 0.18.0-beta.5 → 0.18.0

package/dist/db/consts.browser.cjs

@@ -0,0 +1,433 @@
+"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,
+  DbFilterFunctionWhereSchema: () => DbFilterFunctionWhereSchema,
+  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,
+  isMetadataDotFilterField: () => isMetadataDotFilterField
+});
+module.exports = __toCommonJS(consts_exports);
+var import_ts_utils = require("../lib/ts-utils.browser.cjs");
+var import_zod = require("../lib/zod.browser.cjs");
+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 DbFilterFunctionWhereSchema = import_zod.z.discriminatedUnion(
+  "function",
+  [
+    DbFilterFunctionWhereInSchema,
+    DbFilterFunctionWherePrimitiveSchema,
+    DbFilterFunctionWhereNullSchema
+  ]
+);
+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 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 = 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 (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 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);
+  });
+}