@knpkv/control-center 0.1.0

package/dist/server/server/persistence/repositories/deliveryGraphRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliveryGraphRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/deliveryGraphRepository.ts"],"names":[],"mappings":"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"}

package/dist/server/server/persistence/repositories/domainEventModels.d.ts

@@ -0,0 +1,89 @@
+import * as Schema from "effect/Schema";
+import { EventCursor } from "../../../domain/identifiers.js";
+/** Maximum number of durable events read in one replay page. */
+export declare const MAXIMUM_DOMAIN_EVENT_PAGE_SIZE = 128;
+/** Maximum number of durable events removed in one retention transaction. */
+export declare const MAXIMUM_DOMAIN_EVENT_PRUNE_SIZE = 500;
+/** Bounded caller identity used to make event appends idempotent. */
+export declare const DomainEventDedupeKey: Schema.brand<Schema.String, "DomainEventDedupeKey">;
+/** Decoded durable-event deduplication key. */
+export type DomainEventDedupeKey = typeof DomainEventDedupeKey.Type;
+/** Positive workspace-local cursor assigned only to persisted events. */
+export declare const PersistedEventCursor: Schema.brand<Schema.Int, "EventCursor">;
+/** Bounded replay-page size accepted by the repository. */
+export declare const DomainEventPageSize: Schema.brand<Schema.Int, "DomainEventPageSize">;
+/** Decoded replay-page size. */
+export type DomainEventPageSize = typeof DomainEventPageSize.Type;
+/** Bounded retention batch size accepted by the repository. */
+export declare const DomainEventPruneSize: Schema.brand<Schema.Int, "DomainEventPruneSize">;
+/** Decoded retention batch size. */
+export type DomainEventPruneSize = typeof DomainEventPruneSize.Type;
+/** Durable stream head and the highest cursor removed by retention. */
+export declare const DomainEventStreamState: Schema.Struct<{
+    readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+    readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+}>;
+/** Decoded durable stream state. */
+export type DomainEventStreamState = typeof DomainEventStreamState.Type;
+/** Raw persisted event row decoded before payload integrity verification. */
+export declare const DomainEventRow: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+    readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly eventType: Schema.Literal<"portfolio-invalidated">;
+    readonly dedupeKey: Schema.brand<Schema.String, "DomainEventDedupeKey">;
+    readonly releaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+    readonly pluginConnectionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+    readonly entityId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+    readonly jobId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly ingestedAt: Schema.DateTimeUtcFromString;
+    readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+    readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+    readonly payloadJson: Schema.String;
+    readonly payloadDigest: Schema.brand<Schema.String, "BlobDigest">;
+}>;
+/** Decoded raw durable event row. */
+export type DomainEventRow = typeof DomainEventRow.Type;
+/** Caller-provided facts required before the repository assigns a cursor and ingest time. */
+export declare const AppendDomainEventInput: Schema.Struct<{
+    readonly dedupeKey: Schema.brand<Schema.String, "DomainEventDedupeKey">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+    readonly eventType: Schema.Literal<"portfolio-invalidated">;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+    readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+    readonly metadata: Schema.Struct<{
+        readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+        readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+        readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+        readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+    }>;
+    readonly payload: Schema.Struct<{
+        readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+    }>;
+}>;
+/** Decoded input for one idempotent durable-event append. */
+export type AppendDomainEventInput = typeof AppendDomainEventInput.Type;
+/** Result of one bounded replay read. */
+export type DomainEventPage<Event> = {
+    readonly _tag: "page";
+    readonly events: ReadonlyArray<Event>;
+    readonly headCursor: typeof EventCursor.Type;
+    readonly nextCursor: typeof EventCursor.Type;
+    readonly prunedThroughCursor: typeof EventCursor.Type;
+} | {
+    readonly _tag: "reset";
+    readonly headCursor: typeof EventCursor.Type;
+    readonly prunedThroughCursor: typeof EventCursor.Type;
+    readonly reason: "cursor-ahead" | "gap" | "retention";
+    readonly requestedCursor: typeof EventCursor.Type;
+};
+/** Result of one bounded retention transaction. */
+export interface DomainEventPruneResult {
+    readonly deletedCount: number;
+    readonly prunedThroughCursor: typeof EventCursor.Type;
+}
+//# sourceMappingURL=domainEventModels.d.ts.map

package/dist/server/server/persistence/repositories/domainEventModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domainEventModels.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/domainEventModels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAOvC,OAAO,EAGL,WAAW,EAKZ,MAAM,gCAAgC,CAAA;AAIvC,gEAAgE;AAChE,eAAO,MAAM,8BAA8B,MAAM,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,+BAA+B,MAAM,CAAA;AAElD,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,qDAIW,CAAA;AAE5C,+CAA+C;AAC/C,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,yCAA6C,CAAA;AAE9E,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,iDAEW,CAAA;AAE3C,gCAAgC;AAChC,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE,+DAA+D;AAC/D,eAAO,MAAM,oBAAoB,kDAEW,CAAA;AAE5C,oCAAoC;AACpC,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,uEAAuE;AACvE,eAAO,MAAM,sBAAsB;;;EAGjC,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAA;AAEvE,6EAA6E;AAC7E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;EAmBzB,CAAA;AAEF,qCAAqC;AACrC,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,6FAA6F;AAC7F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;EAUjC,CAAA;AAEF,6DAA6D;AAC7D,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAA;AAEvE,yCAAyC;AACzC,MAAM,MAAM,eAAe,CAAC,KAAK,IAC7B;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;IACrC,QAAQ,CAAC,UAAU,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;IAC5C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;CACtD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;IAC5C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;IACrD,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,KAAK,GAAG,WAAW,CAAA;IACrD,QAAQ,CAAC,eAAe,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;CAClD,CAAA;AAEH,mDAAmD;AACnD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;CACtD"}

package/dist/server/server/persistence/repositories/domainEventRepository.d.ts

@@ -0,0 +1,85 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Database } from "../Database.js";
+import { PersistedRecordError, PersistenceOperationError, type QuarantineWriteError, SourceIdentityMismatchError } from "../errors.js";
+import { type DomainEventPage, type DomainEventPruneResult } from "./domainEventModels.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+declare const makeDomainEventRepository: Effect.Effect<{
+    append: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: Schema.Struct.ReadonlySide<{
+        readonly dedupeKey: Schema.brand<Schema.String, "DomainEventDedupeKey">;
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly ingestedAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }, "Type">, SourceIdentityMismatchError | PersistenceOperationError | PersistedRecordError | QuarantineWriteError, never>;
+    pageAfter: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, after: number & import("effect/Brand").Brand<"EventCursor">, requestedLimit: number) => Effect.Effect<DomainEventPage<Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly ingestedAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }, "Type">>, PersistenceOperationError | QuarantineWriteError, never>;
+    prune: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, throughCursor: number & import("effect/Brand").Brand<"EventCursor">, requestedLimit: number) => Effect.Effect<DomainEventPruneResult, PersistenceOperationError, never>;
+    streamState: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+    }, "Type">, PersistenceOperationError, never>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Workspace-local durable event outbox with bounded replay and retention. */
+export interface DomainEventRepositoryService extends Success<typeof makeDomainEventRepository> {
+}
+declare const DomainEventRepository_base: Context.ServiceClass<DomainEventRepository, "@knpkv/control-center/DomainEventRepository", DomainEventRepositoryService>;
+/** Effect service for durable workspace event streams. */
+export declare class DomainEventRepository extends DomainEventRepository_base {
+    /** Layer that binds event queries, integrity checks, and quarantine writes. */
+    static readonly layer: Layer.Layer<DomainEventRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+export {};
+//# sourceMappingURL=domainEventRepository.d.ts.map

package/dist/server/server/persistence/repositories/domainEventRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domainEventRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/domainEventRepository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,KAAK,oBAAoB,EACzB,2BAA2B,EAC5B,MAAM,cAAc,CAAA;AACrB,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,sBAAsB,EAM5B,MAAM,wBAAwB,CAAA;AAI/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAkChE,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAmc7B,CAAA;AAEF,8EAA8E;AAC9E,MAAM,WAAW,4BAA6B,SAAQ,OAAO,CAAC,OAAO,yBAAyB,CAAC;CAAG;;AAElG,0DAA0D;AAC1D,qBAAa,qBAAsB,SAAQ,0BAGO;IAChD,+EAA+E;IAC/E,MAAM,CAAC,QAAQ,CAAC,KAAK,6FAAiE;CACvF"}

package/dist/server/server/persistence/repositories/entityRepository.d.ts

@@ -0,0 +1,134 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { EntityId, type PluginConnectionId } from "../../../domain/identifiers.js";
+import { ProviderId, SourceRevision, VendorImmutableId } from "../../../domain/sourceRevision.js";
+import { UtcTimestamp } from "../../../domain/utcTimestamp.js";
+import { Database } from "../Database.js";
+import { PersistedRecordError, PersistenceOperationError, RecordNotFoundError } from "../errors.js";
+import { EntityKind, RecordRevision } from "./models.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+declare const makeEntityRepository: Effect.Effect<{
+    create: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: {
+        readonly entityId: EntityId;
+        readonly entityType: EntityKind;
+        readonly sourceRevision: SourceRevision;
+        readonly createdAt: UtcTimestamp;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly sourceRevision: Schema.Struct<{
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | import("../errors.js").RecordAlreadyExistsError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    findBySourceIdentity: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, identity: {
+        readonly pluginConnectionId: PluginConnectionId;
+        readonly providerId: ProviderId;
+        readonly vendorImmutableId: VendorImmutableId;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly sourceRevision: Schema.Struct<{
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    get: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, entityId: string & import("effect/Brand").Brand<"EntityId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly sourceRevision: Schema.Struct<{
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    list: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly sourceRevision: Schema.Struct<{
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], PersistenceOperationError | import("../errors.js").QuarantineWriteError, never>;
+    updateSourceRevision: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, entityId: string & import("effect/Brand").Brand<"EntityId">, input: {
+        readonly sourceRevision: SourceRevision;
+        readonly expectedRevision: RecordRevision;
+        readonly updatedAt: UtcTimestamp;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly sourceRevision: Schema.Struct<{
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Workspace-scoped normalized entity persistence with immutable revisions. */
+export interface EntityRepositoryService extends Success<typeof makeEntityRepository> {
+}
+declare const EntityRepository_base: Context.ServiceClass<EntityRepository, "@knpkv/control-center/EntityRepository", EntityRepositoryService>;
+/** Effect service for normalized delivery entities. */
+export declare class EntityRepository extends EntityRepository_base {
+    /** Layer that binds SQL queries to the shared database at construction. */
+    static readonly layer: Layer.Layer<EntityRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+export {};
+//# sourceMappingURL=entityRepository.d.ts.map

package/dist/server/server/persistence/repositories/entityRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/entityRepository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAe,MAAM,gCAAgC,CAAA;AAC/F,OAAO,EAEL,UAAU,EAEV,cAAc,EAEd,iBAAiB,EAClB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EAEpB,MAAM,cAAc,CAAA;AAQrB,OAAO,EAAqB,UAAU,EAAgB,cAAc,EAAE,MAAM,aAAa,CAAA;AACzF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAuEhE,QAAA,MAAM,oBAAoB;;2BAoOC,QAAQ;6BACN,UAAU;iCACN,cAAc;4BACnB,YAAY;;;;;;;;;;;;;;;;;;;;;qCAlCL,kBAAkB;6BAC1B,UAAU;oCACH,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAiGlB,cAAc;mCACZ,cAAc;4BACrB,YAAY;;;;;;;;;;;;;;;;;;;;0DAkEtC,CAAA;AAEF,+EAA+E;AAC/E,MAAM,WAAW,uBAAwB,SAAQ,OAAO,CAAC,OAAO,oBAAoB,CAAC;CAAG;;AAExF,uDAAuD;AACvD,qBAAa,gBAAiB,SAAQ,qBAErC;IACC,2EAA2E;IAC3E,MAAM,CAAC,QAAQ,CAAC,KAAK,wFAAuD;CAC7E"}