wapi-client 0.18.0-beta.5 → 0.18.0

package/dist/db/consts.browser.js

@@ -0,0 +1,415 @@
+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
+};