@effect-app/infra 4.0.0-beta.11 → 4.0.0-beta.111

package/src/Store/Cosmos.ts

@@ -9,6 +9,7 @@ import { InfraLogger } from "../logger.js"
 import type { FieldValues } from "../Model/filter/types.js"
 import { type RawQuery } from "../Model/query.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
+import { storeId } from "./Memory.js"
 import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "./service.js"
 
 const makeMapId =
@@ -46,11 +47,29 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               id: containerId,
               uniqueKeyPolicy: config?.uniqueKeys
                 ? { uniqueKeys: config.uniqueKeys }
-                : undefined
+                : undefined,
+              partitionKey: {
+                paths: ["/_partitionKey"],
+                version: 2 // support large partitionkeys so that the hash is not based on just the first 100 bytes!
+              }
             }))
           )
 
-          const mainPartitionKey = config?.partitionValue() ?? "primary"
+          const basePartitionKey = config?.partitionValue() ?? "primary"
+          const nsPrefix = (ns: string) => ns === "primary" ? "" : `${ns}::`
+          const nsPartitionValue = (ns: string, e?: Encoded) => {
+            const base = config?.partitionValue(e) ?? "primary"
+            return `${nsPrefix(ns)}${base}`
+          }
+          const nsBasePartitionKey = (ns: string) => `${nsPrefix(ns)}${basePartitionKey}`
+          const resolveNamespace = !config?.allowNamespace
+            ? Effect.succeed("primary")
+            : storeId.asEffect().pipe(Effect.map((namespace) => {
+              if (namespace !== "primary" && !config.allowNamespace!(namespace)) {
+                throw new Error(`Namespace ${namespace} not allowed!`)
+              }
+              return namespace
+            }))
 
           const defaultValues = config?.defaultValues ?? {}
           const container = db.container(containerId)
@@ -60,7 +79,59 @@ function makeCosmosStore({ prefix }: StorageConfig) {
           // then need to clean up the actual data.. perhaps first do with a config toggle to prescribe to it.
           const importedMarkerId = containerId
 
-          const bulkSet = (items: NonEmptyReadonlyArray<PM>) =>
+          const ctx = yield* Effect.context<R>()
+          const seedCache = new Map<string, Effect.Effect<void>>()
+          const makeSeedEffect = (ns: string) => {
+            const markerId = ns === "primary" ? importedMarkerId : `${importedMarkerId}::${ns}`
+            return Effect
+              .promise(() =>
+                container
+                  .item(markerId, markerId)
+                  .read<{ id: string }>()
+                  .then(({ resource }) => Option.fromNullishOr(resource))
+              )
+              .pipe(
+                Effect.flatMap((marker) => {
+                  if (Option.isSome(marker)) return Effect.void
+                  return InfraLogger.logInfo(`Creating mock data for ${name} (namespace: ${ns})`).pipe(
+                    Effect.andThen(seed!),
+                    Effect.flatMap((m) =>
+                      Effect.flatMapOption(
+                        Effect.succeed(toNonEmptyArray([...m])),
+                        (a) => bulkSetInternal(a, ns).pipe(Effect.orDie)
+                      )
+                    ),
+                    Effect.andThen(
+                      Effect.promise(() =>
+                        container.items.create({
+                          _partitionKey: markerId,
+                          id: markerId,
+                          ttl: -1
+                        })
+                      )
+                    ),
+                    Effect.provide(ctx),
+                    Effect.orDie
+                  )
+                }),
+                Effect.withLogSpan(`Cosmos.seedCheck ${name} in ${ns} [effect-app/infra/Store]`),
+                Effect.withSpan("Cosmos.seed [effect-app/infra/Store]", { attributes: { name, namespace: ns } })
+              )
+          }
+          const seedNamespace = Effect.fn("seedNamespace")(function*(ns: string) {
+            if (!seed) return
+            let cached = seedCache.get(ns)
+            if (!cached) {
+              cached = yield* Effect.cached(makeSeedEffect(ns))
+              seedCache.set(ns, cached)
+            }
+            yield* cached
+          })
+          const resolveAndSeed = resolveNamespace.pipe(
+            Effect.tap((ns) => seedNamespace(ns))
+          )
+
+          const bulkSetInternal = (items: NonEmptyReadonlyArray<PM>, ns: string) =>
             Effect
               .gen(function*() {
                 // TODO: disable batching if need atomicity
@@ -77,7 +148,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                               resourceBody: {
                                 ...Struct.omit(x, ["_etag", idKey]),
                                 id: x[idKey],
-                                _partitionKey: config?.partitionValue(x)
+                                _partitionKey: nsPartitionValue(ns, x)
                               }
                               // don't use this or we get an error that the request and some item partition key dont match - makese no sense
                               // partitionKey: config?.partitionValue(x)
@@ -89,7 +160,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                               resourceBody: {
                                 ...Struct.omit(x, ["_etag", idKey]),
                                 id: x[idKey],
-                                _partitionKey: config?.partitionValue(x)
+                                _partitionKey: nsPartitionValue(ns, x)
                               },
                               ifMatch: eTag
                               // don't use this or we get an error that the request and some item partition key dont match - makese no sense
@@ -108,7 +179,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                       .promise(() => bulk(batch.map(([, op]) => op)))
                       .pipe(
                         Effect
-                          .delay(Duration.millis(i === 0 ? 0 : 1100)),
+                          .delay(Duration.millis(i === 0 ? 0 : 150)),
                         Effect
                           .flatMap((responses) =>
                             Effect.gen(function*() {
@@ -161,139 +232,178 @@ function makeCosmosStore({ prefix }: StorageConfig) {
 
                 return batchResult.flat() as unknown as NonEmptyReadonlyArray<Encoded>
               })
-              .pipe(Effect.withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
-                attributes: { "repository.container_id": containerId, "repository.model_name": name }
-              }, { captureStackTrace: false }))
+              .pipe(
+                Effect.withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
+                  attributes: { "repository.container_id": containerId, "repository.model_name": name, namespace: ns }
+                }, { captureStackTrace: false })
+              )
+
+          const bulkSet = (items: NonEmptyReadonlyArray<PM>) =>
+            resolveAndSeed.pipe(Effect.flatMap((ns) => bulkSetInternal(items, ns)))
 
           const batchSet = (items: NonEmptyReadonlyArray<PM>) => {
-            return Effect
-              .suspend(() => {
-                const batch = [...items].map(
-                  (x) =>
-                    [
-                      x,
-                      Option.match(Option.fromNullishOr(x._etag), {
-                        onNone: () => ({
-                          operationType: "Create" as const,
-                          resourceBody: {
-                            ...Struct.omit(x, ["_etag", idKey]),
-                            id: x[idKey],
-                            _partitionKey: config?.partitionValue(x)
-                          }
-                          // don't use this or we get an error that the request and some item partition key dont match - makese no sense
-                          // partitionKey: config?.partitionValue(x)
-                        }),
-                        onSome: (eTag) => ({
-                          operationType: "Replace" as const,
-                          id: x[idKey],
-                          resourceBody: {
-                            ...Struct.omit(x, ["_etag", idKey]),
-                            id: x[idKey],
-                            _partitionKey: config?.partitionValue(x)
-                          },
-                          // don't use this or we get an error that the request and some item partition key dont match - makese no sense
-                          // partitionKey: config?.partitionValue(x)
-                          ifMatch: eTag
-                        })
-                      })
-                    ] as const
-                )
+            return resolveAndSeed
+              .pipe(Effect.flatMap((ns) =>
+                Effect
+                  .suspend(() => {
+                    const batch = [...items].map(
+                      (x) =>
+                        [
+                          x,
+                          Option.match(Option.fromNullishOr(x._etag), {
+                            onNone: () => ({
+                              operationType: "Create" as const,
+                              resourceBody: {
+                                ...Struct.omit(x, ["_etag", idKey]),
+                                id: x[idKey],
+                                _partitionKey: nsPartitionValue(ns, x)
+                              }
+                              // don't use this or we get an error that the request and some item partition key dont match - makese no sense
+                              // partitionKey: config?.partitionValue(x)
+                            }),
+                            onSome: (eTag) => ({
+                              operationType: "Replace" as const,
+                              id: x[idKey],
+                              resourceBody: {
+                                ...Struct.omit(x, ["_etag", idKey]),
+                                id: x[idKey],
+                                _partitionKey: nsPartitionValue(ns, x)
+                              },
+                              // don't use this or we get an error that the request and some item partition key dont match - makese no sense
+                              // partitionKey: config?.partitionValue(x)
+                              ifMatch: eTag
+                            })
+                          })
+                        ] as const
+                    )
 
-                const ex = batch.map(([, c]) => c)
+                    const ex = batch.map(([, c]) => c)
 
-                return Effect
-                  .promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))
-                  .pipe(Effect.flatMap(Effect.fnUntraced(function*(x) {
-                    const result = x.result ?? []
-                    const firstFailed = result.find(
-                      (x: any) => x.statusCode > 299 || x.statusCode < 200
-                    )
-                    if (firstFailed) {
-                      const code = firstFailed.statusCode ?? 0
-                      if (code === 412 || code === 404 || code === 409) {
-                        return yield* new OptimisticConcurrencyException({ type: name, id: "batch", code })
-                      }
+                    return Effect
+                      .promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))
+                      .pipe(Effect.flatMap(Effect.fnUntraced(function*(x) {
+                        const result = x.result ?? []
+                        const firstFailed = result.find(
+                          (x: any) => x.statusCode > 299 || x.statusCode < 200
+                        )
+                        if (firstFailed) {
+                          const code = firstFailed.statusCode ?? 0
+                          if (code === 412 || code === 404 || code === 409) {
+                            return yield* new OptimisticConcurrencyException({ type: name, id: "batch", code })
+                          }
 
-                      return yield* Effect.die(
-                        new CosmosDbOperationError("not able to update record: " + code)
-                      )
-                    }
+                          return yield* Effect.die(
+                            new CosmosDbOperationError("not able to update record: " + code)
+                          )
+                        }
 
-                    return batch.map(([e], i) => ({
-                      ...e,
-                      _etag: result[i]?.eTag
-                    })) as unknown as NonEmptyReadonlyArray<Encoded>
-                  })))
-              })
-              .pipe(Effect
-                .withSpan("Cosmos.batchSet [effect-app/infra/Store]", {
-                  attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                }, { captureStackTrace: false }))
+                        return batch.map(([e], i) => ({
+                          ...e,
+                          _etag: result[i]?.eTag
+                        })) as unknown as NonEmptyReadonlyArray<Encoded>
+                      })))
+                  })
+                  .pipe(Effect
+                    .withSpan("Cosmos.batchSet [effect-app/infra/Store]", {
+                      attributes: {
+                        "repository.container_id": containerId,
+                        "repository.model_name": name,
+                        namespace: ns
+                      }
+                    }, { captureStackTrace: false }))
+              ))
           }
 
           const s: Store<IdKey, Encoded> = {
             queryRaw: <Out>(query: RawQuery<Encoded, Out>) =>
               Effect
-                .sync(() => query.cosmos({ name }))
+                .all({ q: Effect.sync(() => query.cosmos({ name })), ns: resolveAndSeed })
                 .pipe(
-                  Effect.tap((q) => logQuery(q)),
-                  Effect.flatMap((q) =>
-                    Effect.promise(() =>
+                  Effect.tap(({ q }) => logQuery(q)),
+                  Effect.flatMap(({ ns, q }) =>
+                    Effect
+                      .promise(() =>
+                        container
+                          .items
+                          .query<Out>(q, { partitionKey: nsBasePartitionKey(ns) })
+                          .fetchAll()
+                          .then(({ resources }) =>
+                            resources.map(
+                              (_) => ({ ...defaultValues, ...mapReverseId(_ as any) }) as Out
+                            )
+                          )
+                      )
+                      .pipe(
+                        Effect.withSpan("Cosmos.queryRaw [effect-app/infra/Store]", {
+                          attributes: {
+                            "repository.container_id": containerId,
+                            "repository.model_name": name,
+                            namespace: ns
+                          }
+                        }, { captureStackTrace: false })
+                      )
+                  )
+                ),
+            batchRemove: (ids, partitionKey?: string) =>
+              resolveAndSeed.pipe(Effect.flatMap((ns) =>
+                Effect
+                  .promise(() =>
+                    execBatch(
+                      mutable(ids.map((id) =>
+                        dropUndefinedT({
+                          operationType: "Delete" as const,
+                          id
+                          // don't use this or we get an error that the request and some item partition key dont match - makese no sense
+                          // partitionKey: config?.partitionValue({ [idKey]: id } as Encoded)
+                        })
+                      )),
+                      partitionKey ?? nsBasePartitionKey(ns)
+                    )
+                  )
+                  .pipe(
+                    Effect.withSpan("Cosmos.batchRemove [effect-app/infra/Store]", {
+                      attributes: {
+                        "repository.container_id": containerId,
+                        "repository.model_name": name,
+                        namespace: ns
+                      }
+                    }, { captureStackTrace: false })
+                  )
+              )),
+            all: Effect
+              .all({
+                q: Effect.sync(() => ({
+                  query: `SELECT * FROM ${name}`,
+                  parameters: []
+                })),
+                ns: resolveAndSeed
+              })
+              .pipe(
+                Effect.tap(({ q }) => logQuery(q)),
+                Effect.flatMap(({ ns, q }) =>
+                  Effect
+                    .promise(() =>
                       container
                         .items
-                        .query<Out>(q, { partitionKey: mainPartitionKey })
+                        .query<PMCosmos>(q, { partitionKey: nsBasePartitionKey(ns) })
                         .fetchAll()
                         .then(({ resources }) =>
                           resources.map(
-                            (_) => ({ ...defaultValues, ...mapReverseId(_ as any) }) as Out
+                            (_) => ({ ...defaultValues, ...mapReverseId(_) })
                           )
                         )
                     )
-                  ),
-                  Effect
-                    .withSpan("Cosmos.queryRaw [effect-app/infra/Store]", {
-                      attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                    }, { captureStackTrace: false })
-                ),
-            batchRemove: (ids, partitionKey?: string) =>
-              Effect.promise(() =>
-                execBatch(
-                  mutable(ids.map((id) =>
-                    dropUndefinedT({
-                      operationType: "Delete" as const,
-                      id
-                      // don't use this or we get an error that the request and some item partition key dont match - makese no sense
-                      // partitionKey: config?.partitionValue({ [idKey]: id } as Encoded)
-                    })
-                  )),
-                  partitionKey ?? mainPartitionKey
+                    .pipe(
+                      Effect.withSpan("Cosmos.all [effect-app/infra/Store]", {
+                        attributes: {
+                          "repository.container_id": containerId,
+                          "repository.model_name": name,
+                          namespace: ns
+                        }
+                      }, { captureStackTrace: false })
+                    )
                 )
               ),
-            all: Effect
-              .sync(() => ({
-                query: `SELECT * FROM ${name}`,
-                parameters: []
-              }))
-              .pipe(
-                Effect.tap((q) => logQuery(q)),
-                Effect.flatMap((q) =>
-                  Effect.promise(() =>
-                    container
-                      .items
-                      .query<PMCosmos>(q, { partitionKey: mainPartitionKey })
-                      .fetchAll()
-                      .then(({ resources }) =>
-                        resources.map(
-                          (_) => ({ ...defaultValues, ...mapReverseId(_) })
-                        )
-                      )
-                  )
-                ),
-                Effect
-                  .withSpan("Cosmos.all [effect-app/infra/Store]", {
-                    attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                  }, { captureStackTrace: false })
-              ),
             /**
              * May return duplicate results for "join_find", when matching more than once.
              */
@@ -305,166 +415,153 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               const filter = f.filter
               type M = U extends undefined ? Encoded : Pick<Encoded, U>
               return Effect
-                .sync(() =>
-                  buildWhereCosmosQuery3(
-                    idKey,
-                    filter ? [{ t: "where-scope", result: filter, relation: "some" }] : [],
-                    name,
-                    defaultValues,
-                    f.select as NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }> | undefined,
-                    f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
-                    skip,
-                    limit
-                  )
-                )
+                .all({
+                  q: Effect.sync(() =>
+                    buildWhereCosmosQuery3(
+                      idKey,
+                      filter ? [{ t: "where-scope", result: filter, relation: "some" }] : [],
+                      name,
+                      defaultValues,
+                      f.select as
+                        | NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }>
+                        | undefined,
+                      f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
+                      skip,
+                      limit
+                    )
+                  ),
+                  ns: resolveAndSeed
+                })
                 .pipe(
-                  Effect.tap((q) => logQuery(q)),
+                  Effect.tap(({ q }) => logQuery(q)),
                   Effect
-                    .flatMap((q) =>
-                      Effect.promise(() =>
-                        f.select
-                          ? container
-                            .items
-                            .query<M>(q, { partitionKey: mainPartitionKey })
-                            .fetchAll()
-                            .then(({ resources }) =>
-                              resources.map((_) =>
-                                ({
+                    .flatMap(({ ns, q }) =>
+                      Effect
+                        .promise(() =>
+                          f.select
+                            ? container
+                              .items
+                              .query<M>(q, { partitionKey: nsBasePartitionKey(ns) })
+                              .fetchAll()
+                              .then(({ resources }) =>
+                                resources.map((_) => ({
                                   ...pipe(
                                     defaultValues,
-                                    Struct.pick(f.select!.filter((_) => typeof _ === "string"))
+                                    Struct.pick(f.select!.filter((_) => typeof _ === "string") as never[])
                                   ),
                                   ...mapReverseId(_ as any)
-                                }) as any
+                                }))
                               )
-                            )
-                          : container
-                            .items
-                            .query<{ f: M }>(q, { partitionKey: mainPartitionKey })
-                            .fetchAll()
-                            .then(({ resources }) =>
-                              resources.map(({ f }) => ({ ...defaultValues, ...mapReverseId(f as any) }) as any)
-                            )
-                      )
+                            : container
+                              .items
+                              .query<{ f: M }>(q, { partitionKey: nsBasePartitionKey(ns) })
+                              .fetchAll()
+                              .then(({ resources }) =>
+                                resources.map(({ f }) => ({ ...defaultValues, ...mapReverseId(f as any) }) as any)
+                              )
+                        )
+                        .pipe(
+                          Effect.withSpan("Cosmos.filter [effect-app/infra/Store]", {
+                            attributes: {
+                              "repository.container_id": containerId,
+                              "repository.model_name": name,
+                              namespace: ns
+                            }
+                          }, { captureStackTrace: false })
+                        )
                     )
                 )
-                .pipe(
-                  Effect.withSpan("Cosmos.filter [effect-app/infra/Store]", {
-                    attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                  }, { captureStackTrace: false })
-                )
             },
             find: (id) =>
-              Effect
-                .promise(() =>
-                  container
-                    .item(id, config?.partitionValue({ [idKey]: id } as Encoded))
-                    .read<Encoded>()
-                    .then(({ resource }) =>
-                      Option.fromNullishOr(resource).pipe(Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) })))
-                    )
-                )
-                .pipe(Effect
-                  .withSpan("Cosmos.find [effect-app/infra/Store]", {
-                    attributes: {
-                      "repository.container_id": containerId,
-                      "repository.model_name": name,
-                      partitionValue: config?.partitionValue({ [idKey]: id } as Encoded),
-                      id
-                    }
-                  }, { captureStackTrace: false })),
-            set: (e) =>
-              Option
-                .match(
-                  Option
-                    .fromNullishOr(e._etag),
-                  {
-                    onNone: () =>
-                      Effect.promise(() =>
-                        container.items.create({
-                          ...mapId(e),
-                          _partitionKey: config?.partitionValue(e)
-                        })
-                      ),
-                    onSome: (eTag) =>
-                      Effect.promise(() =>
-                        container.item(e[idKey], config?.partitionValue(e)).replace(
-                          { ...mapId(e), _partitionKey: config?.partitionValue(e) },
-                          {
-                            accessCondition: {
-                              type: "IfMatch",
-                              condition: eTag
-                            }
-                          }
+              resolveAndSeed.pipe(Effect.flatMap((ns) =>
+                Effect
+                  .promise(() =>
+                    container
+                      .item(id, nsPartitionValue(ns, { [idKey]: id } as Encoded))
+                      .read<Encoded>()
+                      .then(({ resource }) =>
+                        Option.fromNullishOr(resource).pipe(
+                          Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) }))
                         )
                       )
-                  }
-                )
-                .pipe(
-                  Effect
-                    .flatMap((x) => {
-                      if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
-                        return Effect.fail(
-                          new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode })
-                        )
-                      }
-                      if (x.statusCode > 299 || x.statusCode < 200) {
-                        return Effect.die(
-                          new CosmosDbOperationError(
-                            "not able to update record: " + x.statusCode
-                          )
-                        )
-                      }
-                      return Effect.sync(() => ({
-                        ...e,
-                        _etag: x.etag
-                      }))
-                    }),
-                  Effect
-                    .withSpan("Cosmos.set [effect-app/infra/Store]", {
+                  )
+                  .pipe(Effect
+                    .withSpan("Cosmos.find [effect-app/infra/Store]", {
                       attributes: {
                         "repository.container_id": containerId,
                         "repository.model_name": name,
-                        id: e[idKey]
+                        partitionValue: nsPartitionValue(ns, { [idKey]: id } as Encoded),
+                        namespace: ns,
+                        id
                       }
-                    }, { captureStackTrace: false })
-                ),
+                    }, { captureStackTrace: false }))
+              )),
+            set: (e) =>
+              resolveAndSeed.pipe(Effect.flatMap((ns) =>
+                Option
+                  .match(
+                    Option
+                      .fromNullishOr(e._etag),
+                    {
+                      onNone: () =>
+                        Effect.promise(() =>
+                          container.items.create({
+                            ...mapId(e),
+                            _partitionKey: nsPartitionValue(ns, e)
+                          })
+                        ),
+                      onSome: (eTag) =>
+                        Effect.promise(() =>
+                          container.item(e[idKey], nsPartitionValue(ns, e)).replace(
+                            { ...mapId(e), _partitionKey: nsPartitionValue(ns, e) },
+                            {
+                              accessCondition: {
+                                type: "IfMatch",
+                                condition: eTag
+                              }
+                            }
+                          )
+                        )
+                    }
+                  )
+                  .pipe(
+                    Effect
+                      .flatMap((x) => {
+                        if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
+                          return Effect.fail(
+                            new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode })
+                          )
+                        }
+                        if (x.statusCode > 299 || x.statusCode < 200) {
+                          return Effect.die(
+                            new CosmosDbOperationError(
+                              "not able to update record: " + x.statusCode
+                            )
+                          )
+                        }
+                        return Effect.sync(() => ({
+                          ...e,
+                          _etag: x.etag
+                        }))
+                      }),
+                    Effect
+                      .withSpan("Cosmos.set [effect-app/infra/Store]", {
+                        attributes: {
+                          "repository.container_id": containerId,
+                          "repository.model_name": name,
+                          namespace: ns,
+                          id: e[idKey]
+                        }
+                      }, { captureStackTrace: false })
+                  )
+              )),
             batchSet,
             bulkSet
           }
 
-          // handle mock data
-          const marker = yield* Effect.promise(() =>
-            container
-              .item(importedMarkerId, importedMarkerId)
-              .read<{ id: string }>()
-              .then(({ resource }) => Option.fromNullishOr(resource))
-          )
+          // Eagerly seed primary namespace on initialization
+          yield* seedNamespace("primary")
 
-          if (!Option.isSome(marker)) {
-            yield* InfraLogger.logInfo("Creating mock data for " + name)
-            if (seed) {
-              const m = yield* seed
-              yield* Effect.flatMapOption(
-                Effect.succeed(toNonEmptyArray([...m])),
-                (a) =>
-                  s.bulkSet(a).pipe(
-                    Effect.orDie,
-                    Effect
-                      // we delay extra here, so that initial creation between Companies/POs also have an interval between them.
-                      .delay(Duration.millis(1100))
-                  )
-              )
-            }
-            // Mark as imported
-            yield* Effect.promise(() =>
-              container.items.create({
-                _partitionKey: importedMarkerId,
-                id: importedMarkerId,
-                ttl: -1
-              })
-            )
-          }
           return s
         })
     }