@effect-app/infra 0.64.0 → 0.66.0

package/.cache/effect/f38adf43700dab905456a534a0690eaf882cff2cd576c731f23d6d14a3c3d659.content

@@ -0,0 +1,360 @@
+import * as tsplus_module_1 from "@effect/io/Effect";
+import * as tsplus_module_2 from "@effect/data/Option";
+import * as tsplus_module_3 from "@effect-app/core/Array";
+import * as tsplus_module_4 from "@effect/data/Chunk";
+import * as tsplus_module_5 from "@effect-app/core/_ext/Iterable";
+import * as tsplus_module_6 from "@effect-app/infra/instrument";
+import * as tsplus_module_7 from "@effect-app/prelude/utils";
+import * as tsplus_module_8 from "@effect-app/core/Effect";
+import * as tsplus_module_9 from "@effect-app/prelude/_ext/misc";
+import * as tsplus_module_10 from "@effect/data/typeclass/Equivalence";
+import * as tsplus_module_11 from "@effect-app/core/_ext/ord.ext";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { CosmosClient } from "@effect-app/infra-adapters/cosmos-client";
+import { omit } from "@effect-app/prelude/utils";
+import { OptimisticConcurrencyException } from "../../errors.js";
+import { StoreMaker } from "./service.js";
+// TODO: Retry operation when running into RU limit.
+export function makeCosmosStore({ prefix }) {
+    return tsplus_module_1.gen(function* ($) {
+        const { db } = yield* $(CosmosClient);
+        return {
+            make: (name, seed, config) => tsplus_module_1.gen(function* ($) {
+                const containerId = `${prefix}${name}`;
+                yield* $(tsplus_module_1.promise(() => db.containers.createIfNotExists({
+                    id: containerId,
+                    uniqueKeyPolicy: config?.uniqueKeys
+                        ? { uniqueKeys: config.uniqueKeys }
+                        : undefined
+                })));
+                const container = db.container(containerId);
+                const bulk = container.items.bulk.bind(container.items);
+                const execBatch = container.items.batch.bind(container.items);
+                const importedMarkerId = containerId;
+                const bulkSet = (items) => tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.gen(function* ($) {
+                    // TODO: disable batching if need atomicity
+                    // we delay and batch to keep low amount of RUs
+                    const b = [...items].map((x) => [
+                        x,
+                        tsplus_module_2.match(tsplus_module_2.fromNullable(x._etag), () => ({
+                            operationType: "Create",
+                            resourceBody: {
+                                ...omit(x, "_etag"),
+                                _partitionKey: config?.partitionValue(x)
+                            },
+                            partitionKey: config?.partitionValue(x)
+                        }), (eTag) => ({
+                            operationType: "Replace",
+                            id: x.id,
+                            resourceBody: {
+                                ...omit(x, "_etag"),
+                                _partitionKey: config?.partitionValue(x)
+                            },
+                            ifMatch: eTag,
+                            partitionKey: config?.partitionValue(x)
+                        }))
+                    ]);
+                    const batches = tsplus_module_4.toReadonlyArray(tsplus_module_3.chunk_(b, config?.maxBulkSize ?? 10));
+                    const batchResult = yield* $(tsplus_module_5.ext_forEach(batches
+                        .map((x, i) => [i, x]), ([i, batch]) => tsplus_module_1.flatMap(tsplus_module_1.delay(tsplus_module_1.promise(() => bulk(batch.map(([, op]) => op))), tsplus_module_3.millis_(i === 0 ? 0 : 1100)), (responses) => tsplus_module_1.gen(function* ($) {
+                        const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404);
+                        if (r) {
+                            return yield* $(tsplus_module_1.fail(new OptimisticConcurrencyException(name, JSON.stringify(r.resourceBody?.["id"]))));
+                        }
+                        const r2 = responses.find((x) => x.statusCode > 299 || x.statusCode < 200);
+                        if (r2) {
+                            return yield* $(tsplus_module_1.die(new CosmosDbOperationError("not able to update record: " + r2.statusCode)));
+                        }
+                        return batch.map(([e], i) => ({
+                            ...e,
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            _etag: responses[i].eTag
+                        }));
+                    }))));
+                    return batchResult.flat();
+                }), "cosmos.bulkSet"), "cosmos.db", containerId);
+                const batchSet = (items) => {
+                    return tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.suspend(() => {
+                        const batch = [...items].map((x) => [
+                            x,
+                            tsplus_module_2.match(tsplus_module_2.fromNullable(x._etag), () => ({
+                                operationType: "Create",
+                                resourceBody: {
+                                    ...omit(x, "_etag"),
+                                    _partitionKey: config?.partitionValue(x)
+                                }
+                            }), (eTag) => ({
+                                operationType: "Replace",
+                                id: x.id,
+                                resourceBody: {
+                                    ...omit(x, "_etag"),
+                                    _partitionKey: config?.partitionValue(x)
+                                },
+                                ifMatch: eTag
+                            }))
+                        ]);
+                        const ex = batch.map(([, c]) => c);
+                        return tsplus_module_1.flatMap(tsplus_module_1.promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey)), (x) => tsplus_module_1.gen(function* ($) {
+                            const result = x.result ?? [];
+                            const firstFailed = result.find((x) => x.statusCode > 299 || x.statusCode < 200);
+                            if (firstFailed) {
+                                const code = firstFailed.statusCode ?? 0;
+                                if (code === 412 || code === 404) {
+                                    return yield* $(tsplus_module_1.fail(new OptimisticConcurrencyException(name, "batch")));
+                                }
+                                return yield* $(tsplus_module_1.die(new CosmosDbOperationError("not able to update record: " + code)));
+                            }
+                            return batch.map(([e], i) => ({
+                                ...e,
+                                _etag: result[i]?.eTag
+                            }));
+                        }));
+                    }), "cosmos.batchSet"), "cosmos.db", containerId);
+                };
+                const s = {
+                    all: tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.flatMap(tsplus_module_1.tap(tsplus_module_1.sync(() => ({
+                        query: `SELECT * FROM ${name} f WHERE f.id != @id`,
+                        parameters: [{ name: "@id", value: importedMarkerId }]
+                    })), (q) => logQuery(q)), (q) => tsplus_module_1.promise(() => container
+                        .items
+                        .query(q)
+                        .fetchAll()
+                        .then(({ resources }) => resources))), "cosmos.all"), "cosmos.db", containerId),
+                    filterJoinSelect: (filter, cursor) => tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.map(tsplus_module_5.ext_forEach(filter
+                        .keys, (k) => tsplus_module_1.flatMap(tsplus_module_1.tap(tsplus_module_1.sync(() => buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit)), (q) => logQuery(q)), (q) => tsplus_module_1.promise(() => container
+                        .items
+                        .query(q)
+                        .fetchAll()
+                        .then(({ resources }) => resources)))), (a) => {
+                        const v = a
+                            .flatMap((_) => _)
+                            .map((x) => tsplus_module_7.spread(x, ({ r, ...rest }) => ({ ...rest, ...r })));
+                        return v;
+                    }), "cosmos.filterJoinSelect"), "cosmos.db", containerId),
+                    /**
+                     * May return duplicate results for "join_find", when matching more than once.
+                     */
+                    filter: (filter, cursor) => {
+                        const skip = cursor?.skip;
+                        const limit = cursor?.limit;
+                        return tsplus_module_1.logAnnotate(tsplus_module_6.instr((filter.type === "join_find"
+                            // This is a problem if one of the multiple joined arrays can be empty!
+                            // https://stackoverflow.com/questions/60320780/azure-cosmosdb-sql-join-not-returning-results-when-the-child-contains-empty-arra
+                            // so we use multiple queries instead.
+                            ? tsplus_module_1.map(tsplus_module_5.ext_forEach(filter
+                                .keys, (k) => tsplus_module_1.flatMap(tsplus_module_1.tap(tsplus_module_1.sync(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit)), (q) => logQuery(q)), (q) => tsplus_module_1.promise(() => container
+                                .items
+                                .query(q)
+                                .fetchAll()
+                                .then(({ resources }) => resources)))), (_) => _.flatMap((_) => _))
+                            : tsplus_module_1.flatMap(tsplus_module_1.tap(tsplus_module_1.sync(() => buildCosmosQuery(filter, name, importedMarkerId, skip, limit)), (q) => logQuery(q)), (q) => tsplus_module_1.promise(() => container
+                                .items
+                                .query(q)
+                                .fetchAll()
+                                .then(({ resources }) => resources.map((_) => _.f))))), "cosmos.filter"), "cosmos.db", containerId);
+                    },
+                    find: (id) => tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.promise(() => container
+                        .item(id, config?.partitionValue({ id }))
+                        .read()
+                        .then(({ resource }) => tsplus_module_2.fromNullable(resource))), "cosmos.find"), "cosmos.db", containerId),
+                    set: (e) => tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.flatMap(tsplus_module_2.match(tsplus_module_2.fromNullable(e._etag), () => tsplus_module_1.promise(() => container.items.create({
+                        ...e,
+                        _partitionKey: config?.partitionValue(e)
+                    })), (eTag) => tsplus_module_1.promise(() => container.item(e.id, config?.partitionValue(e)).replace({ ...e, _partitionKey: config?.partitionValue(e) }, {
+                        accessCondition: {
+                            type: "IfMatch",
+                            condition: eTag
+                        }
+                    }))), (x) => {
+                        if (x.statusCode === 412 || x.statusCode === 404) {
+                            return tsplus_module_1.fail(new OptimisticConcurrencyException(name, e.id));
+                        }
+                        if (x.statusCode > 299 || x.statusCode < 200) {
+                            return tsplus_module_1.die(new CosmosDbOperationError("not able to update record: " + x.statusCode));
+                        }
+                        return tsplus_module_1.sync(() => ({
+                            ...e,
+                            _etag: x.etag
+                        }));
+                    }), "cosmos.set"), "cosmos.db", containerId),
+                    batchSet,
+                    bulkSet,
+                    remove: (e) => tsplus_module_1.logAnnotate(tsplus_module_6.instr(tsplus_module_1.promise(() => container.item(e.id, config?.partitionValue(e)).delete()), "cosmos.remove"), "cosmos.db", containerId)
+                };
+                // handle mock data
+                const marker = yield* $(tsplus_module_1.promise(() => container
+                    .item(importedMarkerId, importedMarkerId)
+                    .read()
+                    .then(({ resource }) => tsplus_module_2.fromNullable(resource))));
+                if (!tsplus_module_2.isSome(marker)) {
+                    console.log("Creating mock data for " + name);
+                    if (seed) {
+                        const m = yield* $(seed);
+                        yield* $(tsplus_module_8.flatMapOption(tsplus_module_1.sync(() => tsplus_module_3.CollectionToNonEmptyReadonlyArray(m)), (a) => tsplus_module_1.delay(tsplus_module_1.orDie(s
+                            .bulkSet(a)), tsplus_module_3.millis_(1100))));
+                    }
+                    // Mark as imported
+                    yield* $(tsplus_module_1.promise(() => container.items.create({
+                        _partitionKey: importedMarkerId,
+                        id: importedMarkerId
+                    })));
+                }
+                return s;
+            })
+        };
+    });
+}
+function logQuery(q) {
+    return tsplus_module_9.logAnnotates({
+        query: q.query,
+        parameters: JSON.stringify(q.parameters.reduce((acc, v) => {
+            acc[v.name] = v.value;
+            return acc;
+        }, {}), undefined, 2)
+    })(tsplus_module_1.logDebug("cosmos query"));
+}
+/**
+ * @deprecated: should build Select into Where query
+ */
+export function buildFilterJoinSelectCosmosQuery(filter, k, name, skip, limit) {
+    const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : "";
+    return {
+        query: `
+SELECT r, f.id as _rootId
+FROM ${name} f
+JOIN r IN f.${k}
+WHERE LOWER(r.${filter.valueKey}) = LOWER(@value)
+${lm}
+`,
+        parameters: [{ name: "@value", value: filter.value }]
+    };
+}
+/**
+ * @deprecated: is now part of Where query as k.-1.valueKey
+ */
+export function buildFindJoinCosmosQuery(filter, k, name, skip, limit) {
+    const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : "";
+    return {
+        query: `
+SELECT DISTINCT VALUE f
+FROM ${name} f
+JOIN r IN f.${k}
+WHERE LOWER(r.${filter.valueKey}) = LOWER(@value)
+${lm}`,
+        parameters: [{ name: "@value", value: filter.value }]
+    };
+}
+/**
+ * @deprecated: should build into Where query
+ */
+export function buildLegacyCosmosQuery(filter, name, importedMarkerId, skip, limit) {
+    const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : "";
+    return {
+        query: `
+    SELECT f
+    FROM ${name} AS f
+    WHERE f.id != @id AND f.${String(filter.by)} LIKE @filter
+  ${lm}`,
+        parameters: [
+            { name: "@id", value: importedMarkerId },
+            {
+                name: "@filter",
+                value: filter.type === "endsWith"
+                    ? `%${filter.value}`
+                    : filter.type === "contains"
+                        ? `%${filter.value}%`
+                        : `${filter.value}%`
+            }
+        ]
+    };
+}
+export function buildWhereCosmosQuery(filter, name, importedMarkerId, skip, limit) {
+    const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : "";
+    return {
+        query: `
+    SELECT f
+    FROM ${name} AS f
+    ${tsplus_module_11.uniqArray(tsplus_module_10.string)(filter
+            .where
+            .filter((_) => _.key.includes(".-1."))
+            .map((_) => _.key.split(".-1.")[0])
+            .map((_) => `JOIN ${_} IN f.${_}`))
+            .join("\n")}
+    WHERE f.id != @id AND ${filter
+            .where
+            .map((_) => _.key.includes(".-1.")
+            ? { ..._, f: _.key.split(".-1.")[0], key: _.key.split(".-1.")[1] }
+            : { ..._, f: "f" })
+            .map((x, i) => {
+            const k = `${x.f}.${x.key}`;
+            const v = `@v${i}`;
+            switch (x.t) {
+                case "in":
+                    return `ARRAY_CONTAINS(${v}, ${k})`;
+                case "not-in":
+                    return `(NOT ARRAY_CONTAINS(${v}, ${k}))`;
+                case "ends-with":
+                    return `ENDSWITH(${k}, ${v}, true)`;
+                case "contains":
+                    return `CONTAINS(${k}, ${v}, true)`;
+                case "starts-with":
+                    return `STARTSWITH(${k}, ${v}, true)`;
+            }
+            const lk = lowerIfNeeded(k, x.value);
+            const lv = lowerIfNeeded(v, x.value);
+            switch (x.t) {
+                case "lt":
+                    return `${lk} < ${lv}`;
+                case "lte":
+                    return `${lk} <= ${lv}`;
+                case "gt":
+                    return `${lk} > ${lv}`;
+                case "gte":
+                    return `${lk} >= ${lv}`;
+                case "not-eq":
+                    return x.value === null
+                        ? `IS_NULL(${k}) = false`
+                        : `${lk} <> ${lv}`;
+                case undefined:
+                case "eq":
+                    return x.value === null
+                        ? `IS_NULL(${k}) = true`
+                        : `${lk} = ${lv}`;
+            }
+        })
+            .join(filter.mode === "or" ? " OR " : " AND ")}
+    ${lm}`,
+        parameters: [
+            { name: "@id", value: importedMarkerId },
+            ...filter
+                .where
+                .map((x, i) => ({
+                name: `@v${i}`,
+                value: x.value
+            }))
+        ]
+    };
+}
+// function isArray(t: SupportedValues | readonly SupportedValues[]): t is readonly SupportedValues[] {
+//   return Array.isArray(t)
+// }
+function lowerIfNeeded(key, value) {
+    return typeof value === "string" ? `LOWER(${key})` : `${key}`;
+}
+export function buildCosmosQuery(filter, name, importedMarkerId, skip, limit) {
+    return filter.type === "startsWith"
+        || filter.type === "endsWith"
+        || filter.type === "contains"
+        ? buildLegacyCosmosQuery(filter, name, importedMarkerId, skip, limit)
+        : buildWhereCosmosQuery(filter, name, importedMarkerId, skip, limit);
+}
+class CosmosDbOperationError {
+    message;
+    constructor(message) {
+        this.message = message;
+    }
+}
+export function CosmosStoreLive(config) {
+    return tsplus_module_1.toLayer(tsplus_module_1.flatMap(tsplus_module_1.config(config), makeCosmosStore), StoreMaker);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Cosmos.js","sourceRoot":"","sources":["../../../_src/services/Store/Cosmos.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { CosmosClient } from \"@effect-app/infra-adapters/cosmos-client\"\nimport { omit } from \"@effect-app/prelude/utils\"\nimport { OptimisticConcurrencyException } from \"../../errors.js\"\nimport type {\n  Filter,\n  FilterJoinSelect,\n  JoinFindFilter,\n  LegacyFilter,\n  PersistenceModelType,\n  StorageConfig,\n  Store,\n  StoreConfig,\n  StoreWhereFilter,\n  SupportedValues\n} from \"./service.js\"\nimport { StoreMaker } from \"./service.js\"\n\n// TODO: Retry operation when running into RU limit.\nexport function makeCosmosStore({ prefix }: StorageConfig) {\n  return Effect.gen(function*($) {\n    const { db } = yield* $(CosmosClient)\n    return {\n      make: <Id extends string, PM extends PersistenceModelType<Id>>(\n        name: string,\n        seed?: Effect<never, never, Iterable<PM>>,\n        config?: StoreConfig<PM>\n      ) =>\n        Effect.gen(function*($) {\n          const containerId = `${prefix}${name}`\n          yield* $(\n            Effect.promise(() =>\n              db.containers.createIfNotExists({\n                id: containerId,\n                uniqueKeyPolicy: config?.uniqueKeys\n                  ? { uniqueKeys: config.uniqueKeys }\n                  : undefined\n              })\n            )\n          )\n          const container = db.container(containerId)\n          const bulk = container.items.bulk.bind(container.items)\n          const execBatch = container.items.batch.bind(container.items)\n          const importedMarkerId = containerId\n\n          const bulkSet = (items: NonEmptyReadonlyArray<PM>) =>\n            Effect\n              .gen(function*($) {\n                // TODO: disable batching if need atomicity\n                // we delay and batch to keep low amount of RUs\n                const b = [...items].map(\n                  (x) =>\n                    [\n                      x,\n                      Option.fromNullable(x._etag).match(\n                        () => ({\n                          operationType: \"Create\" as const,\n                          resourceBody: {\n                            ...omit(x, \"_etag\"),\n                            _partitionKey: config?.partitionValue(x)\n                          } as any,\n                          partitionKey: config?.partitionValue(x)\n                        }),\n                        (eTag) => ({\n                          operationType: \"Replace\" as const,\n                          id: x.id,\n                          resourceBody: {\n                            ...omit(x, \"_etag\"),\n                            _partitionKey: config?.partitionValue(x)\n                          } as any,\n                          ifMatch: eTag,\n                          partitionKey: config?.partitionValue(x)\n                        })\n                      )\n                    ] as const\n                )\n                const batches = b.chunk(config?.maxBulkSize ?? 10).toReadonlyArray\n\n                const batchResult = yield* $(\n                  batches\n                    .map((x, i) => [i, x] as const)\n                    .forEachEffect(\n                      ([i, batch]) =>\n                        Effect\n                          .promise(() => bulk(batch.map(([, op]) => op)))\n                          .delay(Duration.makeMillis(i === 0 ? 0 : 1100))\n                          .flatMap((responses) =>\n                            Effect.gen(function*($) {\n                              const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404)\n                              if (r) {\n                                return yield* $(\n                                  Effect.fail(\n                                    new OptimisticConcurrencyException(\n                                      name,\n                                      JSON.stringify(r.resourceBody?.[\"id\"])\n                                    )\n                                  )\n                                )\n                              }\n                              const r2 = responses.find(\n                                (x) => x.statusCode > 299 || x.statusCode < 200\n                              )\n                              if (r2) {\n                                return yield* $(\n                                  Effect.die(\n                                    new CosmosDbOperationError(\n                                      \"not able to update record: \" + r2.statusCode\n                                    )\n                                  )\n                                )\n                              }\n                              return batch.map(([e], i) => ({\n                                ...e,\n                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n                                _etag: responses[i]!.eTag\n                              }))\n                            })\n                          )\n                    )\n                )\n                return batchResult.flat() as unknown as NonEmptyReadonlyArray<PM>\n              })\n              .instrument(\"cosmos.bulkSet\")\n              .logAnnotate(\"cosmos.db\", containerId)\n\n          const batchSet = (items: NonEmptyReadonlyArray<PM>) => {\n            return Effect\n              .suspend(() => {\n                const batch = [...items].map(\n                  (x) =>\n                    [\n                      x,\n                      Option.fromNullable(x._etag).match(\n                        () => ({\n                          operationType: \"Create\" as const,\n                          resourceBody: {\n                            ...omit(x, \"_etag\"),\n                            _partitionKey: config?.partitionValue(x)\n                          } as any\n                        }),\n                        (eTag) => ({\n                          operationType: \"Replace\" as const,\n                          id: x.id,\n                          resourceBody: {\n                            ...omit(x, \"_etag\"),\n                            _partitionKey: config?.partitionValue(x)\n                          } as any,\n                          ifMatch: eTag\n                        })\n                      )\n                    ] as const\n                )\n\n                const ex = batch.map(([, c]) => c)\n\n                return Effect\n                  .promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))\n                  .flatMap((x) =>\n                    Effect.gen(function*($) {\n                      const result = x.result ?? []\n                      const firstFailed = result.find(\n                        (x: any) => x.statusCode > 299 || x.statusCode < 200\n                      )\n                      if (firstFailed) {\n                        const code = firstFailed.statusCode ?? 0\n                        if (code === 412 || code === 404) {\n                          return yield* $(\n                            Effect.fail(new OptimisticConcurrencyException(name, \"batch\"))\n                          )\n                        }\n\n                        return yield* $(\n                          Effect.die(\n                            new CosmosDbOperationError(\"not able to update record: \" + code)\n                          )\n                        )\n                      }\n\n                      return batch.map(([e], i) => ({\n                        ...e,\n                        _etag: result[i]?.eTag\n                      })) as unknown as NonEmptyReadonlyArray<PM>\n                    })\n                  )\n              })\n              .instrument(\"cosmos.batchSet\")\n              .logAnnotate(\"cosmos.db\", containerId)\n          }\n\n          const s: Store<PM, Id> = {\n            all: Effect({\n              query: `SELECT * FROM ${name} f WHERE f.id != @id`,\n              parameters: [{ name: \"@id\", value: importedMarkerId }]\n            })\n              .tap((q) => logQuery(q))\n              .flatMap((q) =>\n                Effect.promise(() =>\n                  container\n                    .items\n                    .query<PM>(q)\n                    .fetchAll()\n                    .then(({ resources }) => resources)\n                )\n              )\n              .instrument(\"cosmos.all\")\n              .logAnnotate(\"cosmos.db\", containerId),\n            filterJoinSelect: <T extends object>(\n              filter: FilterJoinSelect,\n              cursor?: { skip?: number; limit?: number }\n            ) =>\n              filter\n                .keys\n                .forEachEffect((k) =>\n                  Effect(buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit))\n                    .tap((q) => logQuery(q))\n                    .flatMap((q) =>\n                      Effect.promise(() =>\n                        container\n                          .items\n                          .query<T>(q)\n                          .fetchAll()\n                          .then(({ resources }) => resources)\n                      )\n                    )\n                )\n                .map((a) => {\n                  const v = a\n                    .flatMap((_) => _)\n                    .map((x) =>\n                      spread(\n                        x,\n                        ({ r, ...rest }: any) => ({ ...rest, ...r } as T & { _rootId: string })\n                      )\n                    )\n                  return v\n                })\n                .instrument(\"cosmos.filterJoinSelect\")\n                .logAnnotate(\"cosmos.db\", containerId),\n            /**\n             * May return duplicate results for \"join_find\", when matching more than once.\n             */\n            filter: (filter: Filter<PM>, cursor?: { skip?: number; limit?: number }) => {\n              const skip = cursor?.skip\n              const limit = cursor?.limit\n              return (filter.type === \"join_find\"\n                // This is a problem if one of the multiple joined arrays can be empty!\n                // https://stackoverflow.com/questions/60320780/azure-cosmosdb-sql-join-not-returning-results-when-the-child-contains-empty-arra\n                // so we use multiple queries instead.\n                ? filter\n                  .keys\n                  .forEachEffect((k) =>\n                    Effect(buildFindJoinCosmosQuery(filter, k, name, skip, limit))\n                      .tap((q) => logQuery(q))\n                      .flatMap((q) =>\n                        Effect.promise(() =>\n                          container\n                            .items\n                            .query<PM>(q)\n                            .fetchAll()\n                            .then(({ resources }) => resources)\n                        )\n                      )\n                  )\n                  .map((_) => _.flatMap((_) => _))\n                : Effect(buildCosmosQuery(filter, name, importedMarkerId, skip, limit))\n                  .tap((q) => logQuery(q))\n                  .flatMap((q) =>\n                    Effect.promise(() =>\n                      container\n                        .items\n                        .query<{ f: PM }>(\n                          q\n                        )\n                        .fetchAll()\n                        .then(({ resources }) => resources.map((_) => _.f))\n                    )\n                  ))\n                .instrument(\"cosmos.filter\")\n                .logAnnotate(\"cosmos.db\", containerId)\n            },\n            find: (id) =>\n              Effect\n                .promise(() =>\n                  container\n                    .item(id, config?.partitionValue({ id } as PM))\n                    .read<PM>()\n                    .then(({ resource }) => Option.fromNullable(resource))\n                )\n                .instrument(\"cosmos.find\")\n                .logAnnotate(\"cosmos.db\", containerId),\n            set: (e) =>\n              Option\n                .fromNullable(e._etag)\n                .match(\n                  () =>\n                    Effect.promise(() =>\n                      container.items.create({\n                        ...e,\n                        _partitionKey: config?.partitionValue(e)\n                      })\n                    ),\n                  (eTag) =>\n                    Effect.promise(() =>\n                      container.item(e.id, config?.partitionValue(e)).replace(\n                        { ...e, _partitionKey: config?.partitionValue(e) },\n                        {\n                          accessCondition: {\n                            type: \"IfMatch\",\n                            condition: eTag\n                          }\n                        }\n                      )\n                    )\n                )\n                .flatMap((x) => {\n                  if (x.statusCode === 412 || x.statusCode === 404) {\n                    return Effect.fail(new OptimisticConcurrencyException(name, e.id))\n                  }\n                  if (x.statusCode > 299 || x.statusCode < 200) {\n                    return Effect.die(\n                      new CosmosDbOperationError(\n                        \"not able to update record: \" + x.statusCode\n                      )\n                    )\n                  }\n                  return Effect({\n                    ...e,\n                    _etag: x.etag\n                  })\n                })\n                .instrument(\"cosmos.set\")\n                .logAnnotate(\"cosmos.db\", containerId),\n            batchSet,\n            bulkSet,\n            remove: (e: PM) =>\n              Effect\n                .promise(() => container.item(e.id, config?.partitionValue(e)).delete())\n                .instrument(\"cosmos.remove\")\n                .logAnnotate(\"cosmos.db\", containerId)\n          }\n\n          // handle mock data\n          const marker = yield* $(\n            Effect.promise(() =>\n              container\n                .item(importedMarkerId, importedMarkerId)\n                .read<{ id: string }>()\n                .then(({ resource }) => Option.fromNullable(resource))\n            )\n          )\n\n          if (!marker.isSome()) {\n            console.log(\"Creating mock data for \" + name)\n            if (seed) {\n              const m = yield* $(seed)\n              yield* $(\n                Effect(m.toNonEmptyArray)\n                  .flatMapOpt((a) =>\n                    s\n                      .bulkSet(a)\n                      .orDie\n                      // we delay extra here, so that initial creation between Companies/POs also have an interval between them.\n                      .delay(Duration.makeMillis(1100))\n                  )\n              )\n            }\n            // Mark as imported\n            yield* $(\n              Effect.promise(() =>\n                container.items.create({\n                  _partitionKey: importedMarkerId,\n                  id: importedMarkerId\n                })\n              )\n            )\n          }\n          return s\n        })\n    }\n  })\n}\n\nfunction logQuery(q: {\n  query: string\n  parameters: {\n    name: string\n    value: SupportedValues | readonly SupportedValues[]\n  }[]\n}) {\n  return Effect\n    .logDebug(\"cosmos query\")\n    .apply(Effect.logAnnotates({\n      query: q.query,\n      parameters: JSON.stringify(\n        q.parameters.reduce((acc, v) => {\n          acc[v.name] = v.value\n          return acc\n        }, {} as Record<string, SupportedValues | readonly SupportedValues[]>),\n        undefined,\n        2\n      )\n    }))\n}\n\n/**\n * @deprecated: should build Select into Where query\n */\nexport function buildFilterJoinSelectCosmosQuery(\n  filter: FilterJoinSelect,\n  k: string,\n  name: string,\n  skip?: number,\n  limit?: number\n) {\n  const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : \"\"\n  return {\n    query: `\nSELECT r, f.id as _rootId\nFROM ${name} f\nJOIN r IN f.${k}\nWHERE LOWER(r.${filter.valueKey}) = LOWER(@value)\n${lm}\n`,\n    parameters: [{ name: \"@value\", value: filter.value }]\n  }\n}\n\n/**\n * @deprecated: is now part of Where query as k.-1.valueKey\n */\nexport function buildFindJoinCosmosQuery(\n  filter: JoinFindFilter,\n  k: string,\n  name: string,\n  skip?: number,\n  limit?: number\n) {\n  const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : \"\"\n  return {\n    query: `\nSELECT DISTINCT VALUE f\nFROM ${name} f\nJOIN r IN f.${k}\nWHERE LOWER(r.${filter.valueKey}) = LOWER(@value)\n${lm}`,\n    parameters: [{ name: \"@value\", value: filter.value }]\n  }\n}\n\n/**\n * @deprecated: should build into Where query\n */\nexport function buildLegacyCosmosQuery<PM>(\n  filter: LegacyFilter<PM>,\n  name: string,\n  importedMarkerId: string,\n  skip?: number,\n  limit?: number\n) {\n  const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : \"\"\n  return {\n    query: `\n    SELECT f\n    FROM ${name} AS f\n    WHERE f.id != @id AND f.${\n      String(\n        filter.by\n      )\n    } LIKE @filter\n  ${lm}`,\n    parameters: [\n      { name: \"@id\", value: importedMarkerId },\n      {\n        name: \"@filter\",\n        value: filter.type === \"endsWith\"\n          ? `%${filter.value}`\n          : filter.type === \"contains\"\n          ? `%${filter.value}%`\n          : `${filter.value}%`\n      }\n    ]\n  }\n}\n\nexport function buildWhereCosmosQuery(\n  filter: StoreWhereFilter,\n  name: string,\n  importedMarkerId: string,\n  skip?: number,\n  limit?: number\n) {\n  const lm = skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : \"\"\n  return {\n    query: `\n    SELECT f\n    FROM ${name} AS f\n    ${\n      filter\n        .where\n        .filter((_) => _.key.includes(\".-1.\"))\n        .map((_) => _.key.split(\".-1.\")[0])\n        .map((_) => `JOIN ${_} IN f.${_}`)\n        .uniq(Equivalence.string)\n        .join(\"\\n\")\n    }\n    WHERE f.id != @id AND ${\n      filter\n        .where\n        .map((_) =>\n          _.key.includes(\".-1.\")\n            ? { ..._, f: _.key.split(\".-1.\")[0], key: _.key.split(\".-1.\")[1]! }\n            : { ..._, f: \"f\" }\n        )\n        .map(\n          (x, i) => {\n            const k = `${x.f}.${x.key}`\n            const v = `@v${i}`\n\n            switch (x.t) {\n              case \"in\":\n                return `ARRAY_CONTAINS(${v}, ${k})`\n              case \"not-in\":\n                return `(NOT ARRAY_CONTAINS(${v}, ${k}))`\n              case \"ends-with\":\n                return `ENDSWITH(${k}, ${v}, true)`\n              case \"contains\":\n                return `CONTAINS(${k}, ${v}, true)`\n              case \"starts-with\":\n                return `STARTSWITH(${k}, ${v}, true)`\n            }\n\n            const lk = lowerIfNeeded(k, x.value)\n            const lv = lowerIfNeeded(v, x.value)\n\n            switch (x.t) {\n              case \"lt\":\n                return `${lk} < ${lv}`\n              case \"lte\":\n                return `${lk} <= ${lv}`\n              case \"gt\":\n                return `${lk} > ${lv}`\n              case \"gte\":\n                return `${lk} >= ${lv}`\n              case \"not-eq\":\n                return x.value === null\n                  ? `IS_NULL(${k}) = false`\n                  : `${lk} <> ${lv}`\n              case undefined:\n              case \"eq\":\n                return x.value === null\n                  ? `IS_NULL(${k}) = true`\n                  : `${lk} = ${lv}`\n            }\n          }\n        )\n        .join(filter.mode === \"or\" ? \" OR \" : \" AND \")\n    }\n    ${lm}`,\n    parameters: [\n      { name: \"@id\", value: importedMarkerId },\n      ...filter\n        .where\n        .map((x, i) => ({\n          name: `@v${i}`,\n          value: x.value\n        }))\n    ]\n  }\n}\n\n// function isArray(t: SupportedValues | readonly SupportedValues[]): t is readonly SupportedValues[] {\n//   return Array.isArray(t)\n// }\n\nfunction lowerIfNeeded(key: unknown, value: unknown) {\n  return typeof value === \"string\" ? `LOWER(${key})` : `${key}`\n}\n\nexport function buildCosmosQuery<PM>(\n  filter: LegacyFilter<PM> | StoreWhereFilter,\n  name: string,\n  importedMarkerId: string,\n  skip?: number,\n  limit?: number\n) {\n  return filter.type === \"startsWith\"\n      || filter.type === \"endsWith\"\n      || filter.type === \"contains\"\n    ? buildLegacyCosmosQuery(filter, name, importedMarkerId, skip, limit)\n    : buildWhereCosmosQuery(filter, name, importedMarkerId, skip, limit)\n}\n\nclass CosmosDbOperationError {\n  constructor(readonly message: string) {}\n}\nexport function CosmosStoreLive(config: Config<StorageConfig>) {\n  return config.config.flatMap(makeCosmosStore).toLayer(StoreMaker)\n}\n"]}

package/.cache/effect/f38adf43700dab905456a534a0690eaf882cff2cd576c731f23d6d14a3c3d659.hash

@@ -0,0 +1 @@
+76ac514b63e950709a008303d53d3e9cc91c0bdb845dc16d2b78b8c751391d40

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @effect-app/infra
 
+## 0.66.0
+
+### Minor Changes
+
+- Update packages
+
+### Patch Changes
+
+- Updated dependencies
+  - @effect-app/core@0.53.0
+  - @effect-app/infra-adapters@0.46.0
+  - @effect-app/prelude@0.53.0
+  - @effect-app/schema@0.47.0
+
+## 0.65.0
+
+### Minor Changes
+
+- Update filters
+
 ## 0.64.0
 
 ### Minor Changes

package/_cjs/filter.cjs

@@ -3,15 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.$contains = $contains;
-exports.$endsWith = $endsWith;
-exports.$in = exports.$gte = exports.$gt = void 0;
-exports.$includes = $includes;
-exports.$lte = exports.$lt = exports.$isnt = exports.$is = void 0;
-exports.$notContains = $notContains;
-exports.$notIn = void 0;
-exports.$startsWith = $startsWith;
-exports.Filters = void 0;
+exports.Filters = exports.$startsWith = exports.$notIn = exports.$lte = exports.$lt = exports.$isnt = exports.$is = exports.$in = exports.$gte = exports.$gt = exports.$endsWith = exports.$contains = void 0;
 exports.makeFilters = makeFilters;
 exports.makeWhereFilter = makeWhereFilter;
 const $in = $in_1;
@@ -30,6 +22,12 @@ const $lt = $lt_1;
 exports.$lt = $lt;
 const $lte = $lte_1;
 exports.$lte = $lte;
+const $startsWith = $startsWith_1;
+exports.$startsWith = $startsWith;
+const $endsWith = $endsWith_1;
+exports.$endsWith = $endsWith;
+const $contains = $contains_1;
+exports.$contains = $contains;
 function makeWhereFilter() {
   const f = makeWhereFilter_();
   return f;
@@ -103,18 +101,6 @@ function makeWhereFilter_() {
   const f = Object.assign(helpers.eq, helpers);
   return f;
 }
-/**
- * @tsplus fluent Iterable $contains
- */
-function $contains(_, v) {
-  return $$contains(v);
-}
-/**
- * @tsplus fluent Iterable $notContains
- */
-function $notContains(_, v) {
-  return $$notContains(v);
-}
 /**
  * @tsplus fluent string $in
  * @tsplus fluent boolean $in
@@ -215,16 +201,15 @@ function $in__(...v) {
 function $notIn__(...v) {
   return _ => $notIn_1(_, ...v);
 }
-// function $contains__<A extends SupportedValues, V extends A>(
-//   v: V
-// ) {
-//   return (_: readonly A[]) => $contains(_, v)
-// }
-// function $notContains__<A extends SupportedValues, V extends A>(
-//   v: V
-// ) {
-//   return (_: readonly A[]) => $notContains(_, v)
-// }
+function $startsWith__(v) {
+  return _ => $startsWith_1(_, v);
+}
+function $endsWith__(v) {
+  return _ => $endsWith_1(_, v);
+}
+function $contains__(v) {
+  return _ => $contains_1(_, v);
+}
 const Filters = {
   $is: $is__,
   $isnt: $isnt__,
@@ -233,28 +218,29 @@ const Filters = {
   $gt: $gt__,
   $gte: $gte__,
   $lt: $lt__,
-  $lte: $lte__
-  // $contains: $contains__,
-  // $notContains: $notContains__,
+  $lte: $lte__,
+  $contains: $contains__,
+  $endsWith: $endsWith__,
+  $startsWith: $startsWith__
 };
 /**
  * @tsplus fluent string $startsWith
  */
 exports.Filters = Filters;
-function $startsWith(_, v) {
+function $startsWith_1(_, v) {
   return $$startsWith(v);
 }
 /**
  * @tsplus fluent string $endsWith
  */
-function $endsWith(_, v) {
+function $endsWith_1(_, v) {
   return $$endsWith(v);
 }
 /**
- * @tsplus fluent string $includes
+ * @tsplus fluent string $contains
  */
-function $includes(_, v) {
-  return $$includes(v);
+function $contains_1(_, v) {
+  return $$contains(v);
 }
 function $$in(v) {
   return {
@@ -304,25 +290,12 @@ function $$gte(v) {
     v
   };
 }
-// containsAny, containsAll?
 function $$contains(v) {
   return {
     t: "contains",
     v
   };
 }
-function $$notContains(v) {
-  return {
-    t: "not-contains",
-    v
-  };
-}
-function $$includes(v) {
-  return {
-    t: "includes",
-    v
-  };
-}
 function $$startsWith(v) {
   return {
     t: "starts-with",