@veecode-platform/backstage-plugin-kong-service-manager-backend-dynamic 1.0.1

package/node_modules/zod/src/v4/mini/tests/assignability.test.ts

@@ -0,0 +1,129 @@
+import { test } from "vitest";
+
+import * as z from "zod/v4-mini";
+
+test("assignability", () => {
+  // $ZodString
+  z.string() satisfies z.core.$ZodString;
+
+  // $ZodNumber
+  z.number() satisfies z.core.$ZodNumber;
+
+  // $ZodBigInt
+  z.bigint() satisfies z.core.$ZodBigInt;
+
+  // $ZodBoolean
+  z.boolean() satisfies z.core.$ZodBoolean;
+
+  // $ZodDate
+  z.date() satisfies z.core.$ZodDate;
+
+  // $ZodSymbol
+  z.symbol() satisfies z.core.$ZodSymbol;
+
+  // $ZodUndefined
+  z.undefined() satisfies z.core.$ZodUndefined;
+
+  // $ZodNullable
+  z.nullable(z.string()) satisfies z.core.$ZodNullable;
+
+  // $ZodNull
+  z.null() satisfies z.core.$ZodNull;
+
+  // $ZodAny
+  z.any() satisfies z.core.$ZodAny;
+
+  // $ZodUnknown
+  z.unknown() satisfies z.core.$ZodUnknown;
+
+  // $ZodNever
+  z.never() satisfies z.core.$ZodNever;
+
+  // $ZodVoid
+  z.void() satisfies z.core.$ZodVoid;
+
+  // $ZodArray
+  z.array(z.string()) satisfies z.core.$ZodArray;
+
+  // $ZodObject
+  z.object({ key: z.string() }) satisfies z.core.$ZodObject;
+
+  // $ZodUnion
+  z.union([z.string(), z.number()]) satisfies z.core.$ZodUnion;
+
+  // $ZodIntersection
+  z.intersection(z.string(), z.number()) satisfies z.core.$ZodIntersection;
+
+  // $ZodTuple
+  z.tuple([z.string(), z.number()]) satisfies z.core.$ZodTuple;
+
+  // $ZodRecord
+  z.record(z.string(), z.number()) satisfies z.core.$ZodRecord;
+
+  // $ZodMap
+  z.map(z.string(), z.number()) satisfies z.core.$ZodMap;
+
+  // $ZodSet
+  z.set(z.string()) satisfies z.core.$ZodSet;
+
+  // $ZodLiteral
+  z.literal("example") satisfies z.core.$ZodLiteral;
+
+  // $ZodEnum
+  z.enum(["a", "b", "c"]) satisfies z.core.$ZodEnum;
+
+  // $ZodPromise
+  z.promise(z.string()) satisfies z.core.$ZodPromise;
+
+  // $ZodLazy
+  const lazySchema = z.lazy(() => z.string());
+  lazySchema satisfies z.core.$ZodLazy;
+
+  // $ZodOptional
+  z.optional(z.string()) satisfies z.core.$ZodOptional;
+
+  // $ZodDefault
+  z._default(z.string(), "default") satisfies z.core.$ZodDefault;
+
+  // $ZodTemplateLiteral
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$ZodTemplateLiteral;
+
+  // $ZodCustom
+  z.custom<string>((val) => typeof val === "string") satisfies z.core.$ZodCustom;
+
+  // $ZodTransform
+  z.transform((val) => val as string) satisfies z.core.$ZodTransform;
+
+  // $ZodNonOptional
+  z.nonoptional(z.optional(z.string())) satisfies z.core.$ZodNonOptional;
+
+  // $ZodReadonly
+  z.readonly(z.object({ key: z.string() })) satisfies z.core.$ZodReadonly;
+
+  // $ZodNaN
+  z.nan() satisfies z.core.$ZodNaN;
+
+  // $ZodPipe
+  z.pipe(z.unknown(), z.number()) satisfies z.core.$ZodPipe;
+
+  // $ZodSuccess
+  z.success(z.string()) satisfies z.core.$ZodSuccess;
+
+  // $ZodCatch
+  z.catch(z.string(), "fallback") satisfies z.core.$ZodCatch;
+
+  // $ZodFile
+  z.file() satisfies z.core.$ZodFile;
+});
+
+test("assignability with type narrowing", () => {
+  type _RefinedSchema<T extends z.ZodMiniType<object> | z.ZodMiniUnion> = T extends z.ZodMiniUnion
+    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
+    : T extends z.ZodMiniType<object>
+      ? RefinedTypeSchema<z.output<T>> // <-- Type instantiation is excessively deep and possibly infinite.
+      : never;
+
+  type RefinedTypeSchema<T extends object> = T;
+
+  type RefinedUnionSchema<T extends z.ZodMiniUnion> = T;
+});

package/node_modules/zod/src/v4/mini/tests/brand.test.ts

@@ -0,0 +1,51 @@
+import { expectTypeOf, test } from "vitest";
+import * as z from "../index.js";
+
+test("branded types", () => {
+  const mySchema = z
+    .object({
+      name: z.string(),
+    })
+    .brand<"superschema">();
+
+  // simple branding
+  type MySchema = z.infer<typeof mySchema>;
+  // Using true for type equality assertion
+  expectTypeOf<MySchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema">>();
+
+  const doStuff = (arg: MySchema) => arg;
+  doStuff(z.parse(mySchema, { name: "hello there" }));
+
+  // inheritance
+  const extendedSchema = mySchema.brand<"subschema">();
+  type ExtendedSchema = z.infer<typeof extendedSchema>;
+  expectTypeOf<ExtendedSchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema"> & z.$brand<"subschema">>();
+
+  doStuff(z.parse(extendedSchema, { name: "hello again" }));
+
+  // number branding
+  const numberSchema = z.number().brand<42>();
+  type NumberSchema = z.infer<typeof numberSchema>;
+  expectTypeOf<NumberSchema>().toEqualTypeOf<number & { [z.$brand]: { 42: true } }>();
+
+  // symbol branding
+  const MyBrand: unique symbol = Symbol("hello");
+  type MyBrand = typeof MyBrand;
+  const symbolBrand = z.number().brand<"sup">().brand<typeof MyBrand>();
+  type SymbolBrand = z.infer<typeof symbolBrand>;
+  // number & { [z.$brand]: { sup: true, [MyBrand]: true } }
+  expectTypeOf<SymbolBrand>().toEqualTypeOf<number & z.$brand<"sup"> & z.$brand<MyBrand>>();
+
+  // keeping brands out of input types
+  const age = z.number().brand<"age">();
+  type Age1 = z.infer<typeof age>;
+  type AgeInput1 = z.input<typeof age>;
+
+  // Using not for type inequality assertion
+  expectTypeOf<AgeInput1>().not.toEqualTypeOf<Age1>();
+  expectTypeOf<number>().toEqualTypeOf<AgeInput1>();
+  expectTypeOf<number & z.$brand<"age">>().toEqualTypeOf<Age1>();
+
+  // @ts-expect-error
+  doStuff({ name: "hello there!" });
+});

package/node_modules/zod/src/v4/mini/tests/checks.test.ts

@@ -0,0 +1,144 @@
+import { expect, test } from "vitest";
+import * as z from "../index.js";
+
+// lt;
+test("z.lt", () => {
+  const a = z.number().check(z.lt(10));
+  expect(z.safeParse(a, 9).success).toEqual(true);
+  expect(z.safeParse(a, 9).data).toEqual(9);
+  expect(z.safeParse(a, 10).success).toEqual(false);
+});
+
+// lte;
+test("z.lte", () => {
+  const a = z.number().check(z.lte(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 11).success).toEqual(false);
+});
+
+// min;
+test("z.max", () => {
+  const a = z.number().check(z.maximum(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 11).success).toEqual(false);
+});
+
+// gt;
+test("z.gt", () => {
+  const a = z.number().check(z.gt(10));
+  expect(z.safeParse(a, 11).success).toEqual(true);
+  expect(z.safeParse(a, 11).data).toEqual(11);
+  expect(z.safeParse(a, 10).success).toEqual(false);
+});
+
+// gte;
+test("z.gte", () => {
+  const a = z.number().check(z.gte(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 9).success).toEqual(false);
+});
+
+// min;
+test("z.min", () => {
+  const a = z.number().check(z.minimum(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 9).success).toEqual(false);
+});
+
+// maxSize;
+test("z.maxLength", () => {
+  const a = z.array(z.string()).check(z.maxLength(3));
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
+});
+
+// minSize;
+test("z.minLength", () => {
+  const a = z.array(z.string()).check(z.minLength(3));
+  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+});
+
+// size;
+test("z.length", () => {
+  const a = z.array(z.string()).check(z.length(3));
+  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
+});
+
+// regex;
+test("z.regex", () => {
+  const a = z.string().check(z.regex(/^aaa$/));
+  expect(z.safeParse(a, "aaa")).toMatchObject({ success: true, data: "aaa" });
+  expect(z.safeParse(a, "aa")).toMatchObject({ success: false });
+});
+
+// includes;
+test("z.includes", () => {
+  const a = z.string().check(z.includes("asdf"));
+  z.parse(a, "qqqasdfqqq");
+  z.parse(a, "asdf");
+  z.parse(a, "qqqasdf");
+  z.parse(a, "asdfqqq");
+  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
+});
+
+// startsWith;
+test("z.startsWith", () => {
+  const a = z.string().check(z.startsWith("asdf"));
+  z.parse(a, "asdf");
+  z.parse(a, "asdfqqq");
+  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
+});
+
+// endsWith;
+test("z.endsWith", () => {
+  const a = z.string().check(z.endsWith("asdf"));
+  z.parse(a, "asdf");
+  z.parse(a, "qqqasdf");
+  expect(z.safeParse(a, "asdfqqq")).toMatchObject({ success: false });
+});
+
+// lowercase;
+test("z.lowercase", () => {
+  const a = z.string().check(z.lowercase());
+  z.parse(a, "asdf");
+  expect(z.safeParse(a, "ASDF")).toMatchObject({ success: false });
+});
+
+// uppercase;
+test("z.uppercase", () => {
+  const a = z.string().check(z.uppercase());
+  z.parse(a, "ASDF");
+  expect(z.safeParse(a, "asdf")).toMatchObject({ success: false });
+});
+
+// filename;
+// fileType;
+// overwrite;
+test("z.overwrite", () => {
+  const a = z.string().check(z.overwrite((val) => val.toUpperCase()));
+  expect(z.safeParse(a, "asdf")).toMatchObject({ data: "ASDF" });
+});
+
+// normalize;
+// trim;
+// toLowerCase;
+// toUpperCase;
+// property
+
+test("abort early", () => {
+  const schema = z.string().check(
+    z.refine((val) => val.length > 1),
+    z.refine((val) => val.length > 2, { abort: true }),
+    z.refine((val) => val.length > 3)
+  );
+  const data = "";
+  const result = z.safeParse(schema, data);
+  expect(result.error!.issues.length).toEqual(2);
+});

package/node_modules/zod/src/v4/mini/tests/computed.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4-mini";
+import { util as zc } from "zod/v4/core";
+
+test("min/max", () => {
+  const a = z.number().check(z.minimum(5), z.minimum(6), z.minimum(7), z.maximum(10), z.maximum(11), z.maximum(12));
+
+  expect(a._zod.bag.minimum).toEqual(7);
+  expect(a._zod.bag.maximum).toEqual(10);
+});
+
+test("multipleOf", () => {
+  const b = z.number().check(z.multipleOf(5));
+  expect(b._zod.bag.multipleOf).toEqual(5);
+});
+
+test("int64 format", () => {
+  const c = z.int64();
+  expect(c._zod.bag.format).toEqual("int64");
+  expect(c._zod.bag.minimum).toEqual(zc.BIGINT_FORMAT_RANGES.int64[0]);
+  expect(c._zod.bag.maximum).toEqual(zc.BIGINT_FORMAT_RANGES.int64[1]);
+});
+
+test("int32 format", () => {
+  const d = z.int32();
+  expect(d._zod.bag.format).toEqual("int32");
+  expect(d._zod.bag.minimum).toEqual(zc.NUMBER_FORMAT_RANGES.int32[0]);
+  expect(d._zod.bag.maximum).toEqual(zc.NUMBER_FORMAT_RANGES.int32[1]);
+});
+
+test("array size", () => {
+  const e = z.array(z.string()).check(z.length(5));
+  expect(e._zod.bag.length).toEqual(5);
+  expect(e._zod.bag.minimum).toEqual(5);
+  expect(e._zod.bag.maximum).toEqual(5);
+});

package/node_modules/zod/src/v4/mini/tests/error.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4-mini";
+
+test("no locale by default", () => {
+  const result = z.safeParse(z.string(), 12);
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].message).toEqual("Invalid input");
+});
+
+test("error inheritance", () => {
+  const e1 = z.string().safeParse(123).error!;
+  expect(e1).toBeInstanceOf(z.core.$ZodError);
+  // expect(e1).not.toBeInstanceOf(Error);
+
+  try {
+    z.string().parse(123);
+  } catch (e2) {
+    expect(e2).toBeInstanceOf(z.core.$ZodRealError);
+    expect(e2).toBeInstanceOf(Error);
+  }
+});

package/node_modules/zod/src/v4/mini/tests/functions.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "vitest";
+// import * as z from "zod/v4/core";
+
+test("z.function", () => {
+  expect(true).toEqual(true);
+});
+
+// test("z.function", () => {
+//   const a = z.function({
+//     args: z.tuple([z.string()]),
+//     returns: z.string(),
+//   });
+
+//   const myFunc = a.implement((name: string | number) => `Hello, ${name}!`);
+
+//   expect(myFunc("world")).toEqual("Hello, world!");
+//   expect(() => myFunc(123 as any)).toThrow();
+
+//   // this won't run
+//   () => {
+//     // @ts-expect-error
+//     const r = myFunc(123);
+//     expectTypeOf(r).toEqualTypeOf<string>();
+//   };
+// });
+
+// test("z.function async", async () => {
+//   const b = z.function({
+//     args: z.tuple([z.string()]).$check(async (_) => {}),
+//     returns: z.string().$check(async (_) => {}),
+//   });
+//   const myFuncAsync = b.implementAsync(async (name) => `Hello, ${name}!`);
+
+//   expect(await myFuncAsync("world")).toEqual("Hello, world!");
+//   expect(myFuncAsync(123 as any)).rejects.toThrow();
+
+//   // this won't run
+//   () => {
+//     // @ts-expect-error
+//     const r = myFuncAsync(123);
+//     expectTypeOf(r).toEqualTypeOf<Promise<string>>();
+//   };
+// });