@effect-app/infra 2.16.6 → 2.16.7

package/test/query.test.ts

@@ -36,9 +36,10 @@ const q = make<Something.Encoded>()
     ),
     order("displayName"),
     page({ take: 10 }),
+    // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
     project(
       S.transformToOrFail(
-        S.Struct({ id: S.StringId, displayName: S.String }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+        S.Struct(Struct.pick(Something.fields, "id", "displayName")),
         S.Struct(Struct.pick(Something.fields, "id", "displayName")),
         (_) => Effect.andThen(SomeService, _)
       )
@@ -84,7 +85,12 @@ it("works", () => {
   const interpreted = toFilter(q)
   console.log("interpreted", inspect(interpreted, undefined, 25))
 
-  const processed = memFilter(interpreted)(items.map((_) => S.encodeSync(Something)(_)))
+  const processed = memFilter(interpreted)(items.map((_) =>
+    S.encodeUnknownSync(S.Struct({
+      ...Something.omit("displayName"),
+      displayName: S.Literal("Verona", "Riley")
+    }))(_)
+  ))
 
   expect(processed).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
 })
@@ -114,7 +120,6 @@ it("works with repo", () =>
       yield* somethingRepo.saveAndPublish(items)
 
       const q1 = yield* somethingRepo.query(() => q)
-      // same as above, but with the `flow` helper
       const q2 = yield* somethingRepo
         .query(
           where("displayName", "Verona"),
@@ -124,9 +129,10 @@ it("works with repo", () =>
           ),
           order("displayName"),
           page({ take: 10 }),
+          // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
           project(
             S.transformToOrFail(
-              S.Struct({ displayName: S.String }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+              S.Struct(Struct.pick(Something.fields, "displayName")),
               S.Struct(Struct.pick(Something.fields, "displayName")),
               (_) => Effect.andThen(SomeService, _)
             )
@@ -156,10 +162,13 @@ it("collect", () =>
           .query(
             where("displayName", "Riley"), // TODO: work with To type translation, so Date?
             // one,
+            // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
             project(
               S.transformTo(
-                // TODO: sample case with narrowing down a union?
-                S.encodedSchema(S.Struct(Struct.pick(Something.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                S.encodedSchema(S.Struct({
+                  ...Struct.pick(Something.fields, "n"),
+                  displayName: S.String
+                })),
                 S.typeSchema(S.Option(S.String)),
                 (_) =>
                   _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
@@ -172,26 +181,39 @@ it("collect", () =>
       )
         .toEqual(["Riley-2020-01-01T00:00:00.000Z"])
 
-      expect(
-        yield* somethingRepo
-          .query(
-            where("union._tag", "string"),
-            one,
-            project(
-              S.transformTo(
-                // TODO: sample case with narrowing down a union?
-                S.encodedSchema(S.Struct(Struct.pick(Something.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
-                S.typeSchema(S.Option(S.String)),
-                (_) =>
-                  _.union._tag === "string"
-                    ? Option.some(_.union.value)
-                    : Option.none()
-              ),
-              "collect"
-            )
-          )
+      const queryRes = make<Something.Encoded>().pipe(
+        where("union._tag", "string"),
+        one
       )
-        .toEqual("hi")
+
+      expectTypeOf(queryRes).toEqualTypeOf<
+        QueryEnd<{
+          readonly id: string
+          readonly displayName: string
+          readonly n: string
+          readonly union: {
+            readonly _tag: "string"
+            readonly value: string
+          }
+        }, "one">
+      >()
+
+      const fromRepo = yield* somethingRepo.query(
+        where("union._tag", "string"),
+        one,
+        project(
+          S.Struct({
+            union: S.Struct({
+              _tag: S.Literal("string"),
+              value: S.String
+            })
+          })
+        )
+      )
+      const value = fromRepo.union.value
+
+      expectTypeOf(value).toEqualTypeOf<string>()
+      expect(value).toEqual("hi")
     })
     .pipe(Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())), Effect.runPromise))
 
@@ -229,8 +251,11 @@ it(
     Effect
       .gen(function*() {
         const repo = yield* makeRepo("test", TestUnion, {})
-        const result = (yield* repo.query(where("id", "123"), and("_tag", "animal"))) satisfies readonly Animal[]
-        const result2 = (yield* repo.query(where("_tag", "animal"))) satisfies readonly Animal[]
+        const result = yield* repo.query(where("id", "123"), and("_tag", "animal"))
+        const result2 = yield* repo.query(where("_tag", "animal"))
+
+        expectTypeOf(result).toEqualTypeOf<readonly Animal[]>()
+        expectTypeOf(result2).toEqualTypeOf<readonly Animal[]>()
 
         expect(result).toEqual([])
         expect(result2).toEqual([])
@@ -263,19 +288,34 @@ it(
           d: S.Unknown
         }) {}
 
+        // const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+
         type Union = AA | BB | CC | DD
 
         const query1 = make<Union>().pipe(
           where("id", "bla"),
           and("_tag", "AA")
         )
-        expectTypeOf(query1).toEqualTypeOf<QueryWhere<Union, AA>>()
+        expectTypeOf(query1).toEqualTypeOf<
+          QueryWhere<Union, AA>
+        >()
 
         const query2 = make<Union>().pipe(
           where("_tag", "AA")
         )
         expectTypeOf(query2).toEqualTypeOf<QueryWhere<Union, AA>>()
 
+        const query2a = make<Union>().pipe(
+          where("c", "something")
+        )
+        expectTypeOf(query2a).toEqualTypeOf<
+          QueryWhere<Union, {
+            readonly id: string
+            readonly _tag: "CC"
+            readonly c: {} // from unknown to {} because "something" means that it's not null or undefined
+          }>
+        >()
+
         const query3 = make<Union>().pipe(
           where("_tag", "AA"),
           or(
@@ -283,7 +323,12 @@ it(
             and("_tag", "BB")
           )
         )
-        expectTypeOf(query3).toEqualTypeOf<QueryWhere<Union, AA | BB>>()
+        expectTypeOf(query3).toEqualTypeOf<
+          QueryWhere<
+            Union,
+            AA | BB
+          >
+        >()
 
         const query3b = make<Union>().pipe(
           where("_tag", "AA"),
@@ -329,7 +374,12 @@ it(
             and("_tag", "neq", "BB")
           )
         )
-        expectTypeOf(query7).toEqualTypeOf<QueryWhere<Union, AA | CC | DD>>()
+        expectTypeOf(query7).toEqualTypeOf<
+          QueryWhere<
+            Union,
+            AA | CC | DD
+          >
+        >()
 
         const query8 = make<Union>().pipe(
           where("_tag", "neq", "AA"),
@@ -348,7 +398,12 @@ it(
             )
           )
         )
-        expectTypeOf(query9).toEqualTypeOf<QueryWhere<Union, AA | BB | CC>>()
+        expectTypeOf(query9).toEqualTypeOf<
+          QueryWhere<
+            Union,
+            AA | BB | CC
+          >
+        >()
 
         const query10 = make<Union>().pipe(
           where("id", "AA"),
@@ -361,7 +416,14 @@ it(
           page({ take: 10 }),
           count
         )
-        expectTypeOf(query10).toEqualTypeOf<QueryProjection<AA | BB, S.NonNegativeInt, never, "count">>()
+        expectTypeOf(query10).toEqualTypeOf<
+          QueryProjection<
+            AA | BB,
+            S.NonNegativeInt,
+            never,
+            "count"
+          >
+        >()
 
         const query11 = make<Union>().pipe(
           where("id", "AA"),
@@ -374,11 +436,16 @@ it(
           page({ take: 10 }),
           one
         )
-        expectTypeOf(query11).toEqualTypeOf<QueryEnd<AA | BB, "one">>()
+        expectTypeOf(query11).toEqualTypeOf<
+          QueryEnd<
+            AA | BB,
+            "one"
+          >
+        >()
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.runPromise)
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -408,14 +475,20 @@ it(
 
         type Union = AA | BB | CC | DD
 
+        const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+
         const query1 = make<Union>().pipe(
           where("id", "AA")
         )
         expectTypeOf(query1).toEqualTypeOf<QueryWhere<Union, AA>>()
 
+        const res = yield* repo.query(() => query1)
+
+        expectTypeOf(res).toEqualTypeOf<readonly AA[]>()
+
         expect([]).toEqual([])
       })
-      .pipe(Effect.runPromise)
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -437,7 +510,16 @@ it(
           {}
         )
 
-        const result = yield* repo.query(where("id", "123"), project(schema))
+        const outputSchema = S.Struct({
+          id: S.Literal("123"),
+          createdAt: S
+            .optional(S.Date)
+            .pipe(
+              S.withDefaults({ constructor: () => new Date(), decoding: () => new Date() })
+            )
+        })
+
+        const result = yield* repo.query(where("id", "123"), project(outputSchema))
 
         expect(result).toEqual([])
       })
@@ -473,3 +555,270 @@ it(
       })
       .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
+
+it(
+  "remove null 1",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          literals: S.Union(S.Literal("a", "b", "c"), S.Null)
+        })
+
+        type Schema = typeof schema.Type
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {}
+        )
+
+        const expected = make<Schema>().pipe(
+          where("literals", "neq", null)
+        )
+        expectTypeOf(expected).toEqualTypeOf<
+          QueryWhere<Schema, {
+            readonly id: string
+            readonly literals: "a" | "b" | "c"
+          }>
+        >()
+
+        const result = yield* repo.query(
+          where("literals", "neq", null)
+        )
+
+        expectTypeOf(result).toEqualTypeOf<
+          readonly {
+            readonly id: string
+            readonly literals: "a" | "b" | "c"
+          }[]
+        >()
+
+        expect(result).toEqual([])
+      })
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+)
+
+it(
+  "remove null 2",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          literals: S.Union(S.String, S.Null)
+        })
+
+        type Schema = typeof schema.Type
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {}
+        )
+
+        const expected = make<Schema>().pipe(
+          where("literals", "ciao")
+        )
+        expectTypeOf(expected).toEqualTypeOf<
+          QueryWhere<Schema, {
+            readonly id: string
+            readonly literals: string
+          }>
+        >()
+
+        const result = yield* repo.query(
+          where("literals", "neq", null)
+        )
+
+        expectTypeOf(result).toEqualTypeOf<
+          readonly {
+            readonly id: string
+            readonly literals: string
+          }[]
+        >()
+
+        expect(result).toEqual([])
+      })
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+)
+
+it("remove null from one constituent of a tagged union", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.Class<AA>()({
+        id: S.Literal("AA"),
+        a: S.String
+      }) {}
+
+      class BB extends S.Class<BB>()({
+        id: S.Literal("BB"),
+        b: S.NullOr(S.Number)
+      }) {}
+
+      type Union = AA | BB
+
+      const repo = yield* makeRepo("test", S.Union(AA, BB), {})
+
+      const query1 = make<Union>().pipe(
+        where("id", "AA"),
+        or(
+          where("b", "neq", null)
+        )
+      )
+
+      expectTypeOf(query1).toEqualTypeOf<
+        QueryWhere<
+          Union,
+          AA | {
+            readonly id: "BB"
+            readonly b: number
+          }
+        >
+      >()
+
+      const resQuer1 = yield* repo.query(() => query1)
+
+      expectTypeOf(resQuer1).toEqualTypeOf<
+        readonly ({
+          readonly id: "AA"
+          readonly a: string
+        } | {
+          readonly id: "BB"
+          readonly b: number
+        })[]
+      >()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("refine 3", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.Class<AA>()({
+        id: S.Literal("AA"),
+        a: S.Unknown
+      }) {}
+
+      class BB extends S.Class<BB>()({
+        id: S.Literal("BB"),
+        b: S.Unknown
+      }) {}
+
+      class CC extends S.Class<CC>()({
+        id: S.Literal("CC"),
+        c: S.Unknown
+      }) {}
+
+      class DD extends S.Class<DD>()({
+        id: S.Literal("DD"),
+        d: S.Unknown
+      }) {}
+
+      type Union = AA | BB | CC | DD
+
+      const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+
+      const query1 = make<Union>().pipe(
+        where("id", "AA")
+      )
+
+      expectTypeOf(query1).toEqualTypeOf<QueryWhere<Union, AA>>()
+
+      const resQuer1 = yield* repo.query(where("id", "AA"))
+      expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("my test", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.Class<AA>()({
+        id: S.String,
+        as: S.Array(S.String)
+      }) {}
+
+      const repo = yield* makeRepo("test", AA, {})
+
+      const resQuer1 = yield* repo.query(
+        where("id", "in", ["id1", "id2"]),
+        and(`as.-1`, "startsWith", "a")
+      )
+      expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("refine inner without imposing a projection", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.TaggedClass<AA>()("AA", {
+        a: S.Unknown
+      }) {}
+
+      class BB extends S.TaggedClass<BB>()("BB", {
+        b: S.Unknown
+      }) {}
+
+      class Data extends S.Class<Data>()({
+        id: S.String,
+        union: S.Union(AA, BB)
+      }) {}
+
+      const repo = yield* makeRepo("data", Data, {})
+
+      const query1 = make<Data>().pipe(
+        where("union._tag", "AA"),
+        // I can refine the overall output by providing a proper projection
+        // that mimics the internal refinement of the encoding type
+        project(S.Struct({ union: AA }))
+      )
+      expectTypeOf(query1).toEqualTypeOf<
+        QueryProjection<
+          {
+            readonly id: string
+            readonly union: AA
+          },
+          {
+            readonly union: AA
+          },
+          never,
+          "many"
+        >
+      >()
+
+      const query2 = make<Data>().pipe(
+        where("union._tag", "AA"),
+        // But if I wanna the whole Data as output ignoring the inner refinement
+        // I wanna be able to do so
+        project(S.Struct(Data.pick("union")))
+      )
+
+      expectTypeOf(query2).toEqualTypeOf<
+        QueryProjection<
+          {
+            readonly id: string
+            readonly union: AA
+          },
+          {
+            readonly union: AA | BB
+          },
+          never,
+          "many"
+        >
+      >()
+
+      const resQuer1 = yield* repo.query(() => query1)
+      expectTypeOf(resQuer1).toEqualTypeOf<
+        readonly {
+          readonly union: AA
+        }[]
+      >()
+
+      const resQuer2 = yield* repo.query(() => query2)
+      expectTypeOf(resQuer2).toEqualTypeOf<
+        readonly {
+          readonly union: AA | BB
+        }[]
+      >()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))

package/test/dist/filterApi.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterApi.test.d.ts","sourceRoot":"","sources":["../filterApi.test.ts"],"names":[],"mappings":""}

package/vitest.config.ts.timestamp-1711744615239-dcf257a844e01.mjs

@@ -1,37 +0,0 @@
-// packages/infra/vitest.config.ts
-import { defineConfig } from "file:///Users/patrickroza/pj/effect-app/libs/node_modules/.pnpm/vite@5.2.6_@types+node@20.11.30/node_modules/vite/dist/node/index.js";
-
-// vite.config.base.ts
-import path from "path";
-import fs from "fs";
-var __vite_injected_original_dirname = "/Users/patrickroza/pj/effect-app/libs";
-function makeConfig(dirName) {
-  const prefix = path.resolve(__vite_injected_original_dirname, "packages");
-  const packages = fs.readdirSync(prefix).map((f) => prefix + "/" + f).filter((f) => fs.lstatSync(f).isDirectory());
-  const cfg = {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    //plugins: [autoImport],
-    test: {
-      include: ["./test/**/*.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
-      reporters: "verbose",
-      globals: true
-    },
-    resolve: {
-      alias: packages.reduce((acc, cur) => {
-        acc[JSON.parse(fs.readFileSync(cur + "/package.json", "utf-8")).name] = path.resolve(cur, cur.endsWith("core") ? "dist" : "src");
-        return acc;
-      }, {})
-      // "@effect-app/core/Prelude": path.join(__dirname, "packages/core/src/Prelude.code.ts")
-    }
-  };
-  console.log(cfg);
-  return cfg;
-}
-
-// packages/infra/vitest.config.ts
-var __vite_injected_original_dirname2 = "/Users/patrickroza/pj/effect-app/libs/packages/infra";
-var vitest_config_default = defineConfig(makeConfig(__vite_injected_original_dirname2));
-export {
-  vitest_config_default as default
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsicGFja2FnZXMvaW5mcmEvdml0ZXN0LmNvbmZpZy50cyIsICJ2aXRlLmNvbmZpZy5iYXNlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJjb25zdCBfX3ZpdGVfaW5qZWN0ZWRfb3JpZ2luYWxfZGlybmFtZSA9IFwiL1VzZXJzL3BhdHJpY2tyb3phL3BqL2VmZmVjdC1hcHAvbGlicy9wYWNrYWdlcy9pbmZyYVwiO2NvbnN0IF9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9maWxlbmFtZSA9IFwiL1VzZXJzL3BhdHJpY2tyb3phL3BqL2VmZmVjdC1hcHAvbGlicy9wYWNrYWdlcy9pbmZyYS92aXRlc3QuY29uZmlnLnRzXCI7Y29uc3QgX192aXRlX2luamVjdGVkX29yaWdpbmFsX2ltcG9ydF9tZXRhX3VybCA9IFwiZmlsZTovLy9Vc2Vycy9wYXRyaWNrcm96YS9wai9lZmZlY3QtYXBwL2xpYnMvcGFja2FnZXMvaW5mcmEvdml0ZXN0LmNvbmZpZy50c1wiOy8vLyA8cmVmZXJlbmNlIHR5cGVzPVwidml0ZXN0XCIgLz5cbmltcG9ydCB7IGRlZmluZUNvbmZpZyB9IGZyb20gXCJ2aXRlXCJcbmltcG9ydCBtYWtlQ29uZmlnIGZyb20gXCIuLi8uLi92aXRlLmNvbmZpZy5iYXNlXCJcblxuZXhwb3J0IGRlZmF1bHQgZGVmaW5lQ29uZmlnKG1ha2VDb25maWcoX19kaXJuYW1lKSlcbiIsICJjb25zdCBfX3ZpdGVfaW5qZWN0ZWRfb3JpZ2luYWxfZGlybmFtZSA9IFwiL1VzZXJzL3BhdHJpY2tyb3phL3BqL2VmZmVjdC1hcHAvbGlic1wiO2NvbnN0IF9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9maWxlbmFtZSA9IFwiL1VzZXJzL3BhdHJpY2tyb3phL3BqL2VmZmVjdC1hcHAvbGlicy92aXRlLmNvbmZpZy5iYXNlLnRzXCI7Y29uc3QgX192aXRlX2luamVjdGVkX29yaWdpbmFsX2ltcG9ydF9tZXRhX3VybCA9IFwiZmlsZTovLy9Vc2Vycy9wYXRyaWNrcm96YS9wai9lZmZlY3QtYXBwL2xpYnMvdml0ZS5jb25maWcuYmFzZS50c1wiOy8vLyA8cmVmZXJlbmNlIHR5cGVzPVwidml0ZXN0XCIgLz5cbmltcG9ydCBwYXRoIGZyb20gXCJwYXRoXCJcbmltcG9ydCBmcyBmcm9tIFwiZnNcIlxuaW1wb3J0IEF1dG9JbXBvcnQgZnJvbSBcInVucGx1Z2luLWF1dG8taW1wb3J0L3ZpdGVcIlxuaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcInZpdGVzdC9jb25maWdcIlxuXG4vLyBjb25zdCBhdXRvSW1wb3J0ID0gQXV0b0ltcG9ydCh7XG4vLyAgIGR0czogXCIuL3Rlc3QvYXV0by1pbXBvcnRzLmQudHNcIixcbi8vICAgLy8gaW5jbHVkZTogW1xuLy8gICAvLyAgIC9cXC50ZXN0XFwuW3RqXXN4PyQvIC8vIC50cywgLnRzeCwgLmpzLCAuanN4XG4vLyAgIC8vIF0sXG4vLyAgIGltcG9ydHM6IFtcbi8vICAgICBcInZpdGVzdFwiXG4vLyAgIF1cbi8vIH0pXG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIG1ha2VDb25maWcoZGlyTmFtZT86IHN0cmluZykge1xuICBjb25zdCBwcmVmaXggPSBwYXRoLnJlc29sdmUoX19kaXJuYW1lLCBcInBhY2thZ2VzXCIpXG4gIGNvbnN0IHBhY2thZ2VzID0gZnMucmVhZGRpclN5bmMocHJlZml4KS5tYXAoZiA9PiBwcmVmaXggKyBcIi9cIiArIGYpLmZpbHRlcihmID0+IGZzLmxzdGF0U3luYyhmKS5pc0RpcmVjdG9yeSgpIClcbiAgY29uc3QgY2ZnID0ge1xuICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdmFyLXJlcXVpcmVzXG4gICAgLy9wbHVnaW5zOiBbYXV0b0ltcG9ydF0sXG4gICAgdGVzdDoge1xuICAgICAgaW5jbHVkZTogIFtcIi4vdGVzdC8qKi8qLnRlc3Que2pzLG1qcyxjanMsdHMsbXRzLGN0cyxqc3gsdHN4fVwiXSxcbiAgICAgIHJlcG9ydGVyczogXCJ2ZXJib3NlXCIsXG4gICAgICBnbG9iYWxzOiB0cnVlXG4gICAgfSxcbiAgICByZXNvbHZlOiB7XG4gICAgICBhbGlhczogcGFja2FnZXMucmVkdWNlKChhY2MsIGN1cikgPT4geyAvLyB3b3JrYXJvdW5kIGZvciAvUHJlbHVkZSBpc3N1ZVxuICAgICAgYWNjW0pTT04ucGFyc2UoZnMucmVhZEZpbGVTeW5jKGN1ciArIFwiL3BhY2thZ2UuanNvblwiLCBcInV0Zi04XCIpKS5uYW1lXSA9IHBhdGgucmVzb2x2ZShjdXIsIGN1ci5lbmRzV2l0aChcImNvcmVcIikgPyBcImRpc3RcIiA6IFwic3JjXCIpXG4gICAgICByZXR1cm4gYWNjXG4gICAgfSwgeyB9KSAvLyBcIkBlZmZlY3QtYXBwL2NvcmUvUHJlbHVkZVwiOiBwYXRoLmpvaW4oX19kaXJuYW1lLCBcInBhY2thZ2VzL2NvcmUvc3JjL1ByZWx1ZGUuY29kZS50c1wiKVxuICB9XG4gIH1cbiAgY29uc29sZS5sb2coY2ZnKVxuICByZXR1cm4gY2ZnXG59XG4iXSwKICAibWFwcGluZ3MiOiAiO0FBQ0EsU0FBUyxvQkFBb0I7OztBQ0E3QixPQUFPLFVBQVU7QUFDakIsT0FBTyxRQUFRO0FBRmYsSUFBTSxtQ0FBbUM7QUFnQjFCLFNBQVIsV0FBNEIsU0FBa0I7QUFDbkQsUUFBTSxTQUFTLEtBQUssUUFBUSxrQ0FBVyxVQUFVO0FBQ2pELFFBQU0sV0FBVyxHQUFHLFlBQVksTUFBTSxFQUFFLElBQUksT0FBSyxTQUFTLE1BQU0sQ0FBQyxFQUFFLE9BQU8sT0FBSyxHQUFHLFVBQVUsQ0FBQyxFQUFFLFlBQVksQ0FBRTtBQUM3RyxRQUFNLE1BQU07QUFBQTtBQUFBO0FBQUEsSUFHVixNQUFNO0FBQUEsTUFDSixTQUFVLENBQUMsa0RBQWtEO0FBQUEsTUFDN0QsV0FBVztBQUFBLE1BQ1gsU0FBUztBQUFBLElBQ1g7QUFBQSxJQUNBLFNBQVM7QUFBQSxNQUNQLE9BQU8sU0FBUyxPQUFPLENBQUMsS0FBSyxRQUFRO0FBQ3JDLFlBQUksS0FBSyxNQUFNLEdBQUcsYUFBYSxNQUFNLGlCQUFpQixPQUFPLENBQUMsRUFBRSxJQUFJLElBQUksS0FBSyxRQUFRLEtBQUssSUFBSSxTQUFTLE1BQU0sSUFBSSxTQUFTLEtBQUs7QUFDL0gsZUFBTztBQUFBLE1BQ1QsR0FBRyxDQUFFLENBQUM7QUFBQTtBQUFBLElBQ1I7QUFBQSxFQUNBO0FBQ0EsVUFBUSxJQUFJLEdBQUc7QUFDZixTQUFPO0FBQ1Q7OztBRHBDQSxJQUFNQSxvQ0FBbUM7QUFJekMsSUFBTyx3QkFBUSxhQUFhLFdBQVdDLGlDQUFTLENBQUM7IiwKICAibmFtZXMiOiBbIl9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9kaXJuYW1lIiwgIl9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9kaXJuYW1lIl0KfQo=