@shipfox/api-logs 2.0.0

package/dist/db/streams.js

@@ -0,0 +1,197 @@
+import { and, asc, eq, getTableColumns, isNull, lt, notInArray, sql } from 'drizzle-orm';
+import { LeaseStreamMismatchError } from '#core/errors.js';
+import { db } from './db.js';
+import { attemptStreams, toAttemptStream } from './schema/attempt-streams.js';
+import { logChunks } from './schema/chunks.js';
+/**
+ * Reads the stream for `(job, step, attempt)` without creating it. Used by the
+ * empty-body heartbeat path so a runner cannot mint rows with empty appends.
+ */ export async function getAttemptStream(tx, lookup) {
+    const [row] = await tx.select().from(attemptStreams).where(and(eq(attemptStreams.jobId, lookup.jobId), eq(attemptStreams.stepId, lookup.stepId), eq(attemptStreams.attempt, lookup.attempt)));
+    return row ? toAttemptStream(row) : null;
+}
+/**
+ * Reads the stream for `(step, attempt)` for the session read path, which holds no lease
+ * and so has no `jobId`. `stepId` is a globally unique uuidv7, so `(stepId, attempt)`
+ * selects at most one row even though stream identity is `(jobId, stepId, attempt)`. The
+ * caller authorizes against the row's denormalized `workspaceId`.
+ */ export async function getStreamByStepAttempt(lookup) {
+    const [row] = await db().select().from(attemptStreams).where(and(eq(attemptStreams.stepId, lookup.stepId), eq(attemptStreams.attempt, lookup.attempt)));
+    return row ? toAttemptStream(row) : null;
+}
+/**
+ * Loads the stream for `(job, step, attempt)`, creating it on first append.
+ * Scoped by `jobId` from the lease, so a lease never reaches another job's stream.
+ * The create path reports whether the row was inserted so callers can record
+ * first-open side effects only after their enclosing transaction commits.
+ */ export async function getOrCreateAttemptStreamWithStatus(tx, identity) {
+    const [row] = await tx.insert(attemptStreams).values(identity).onConflictDoUpdate({
+        target: [
+            attemptStreams.jobId,
+            attemptStreams.stepId,
+            attemptStreams.attempt
+        ],
+        set: {
+            updatedAt: sql`now()`
+        }
+    })// Postgres sets `xmax` only on the conflict-update path, so this keeps
+    // first-open detection in the single upsert round trip.
+    .returning({
+        ...getTableColumns(attemptStreams),
+        created: sql`xmax = 0`
+    });
+    if (!row) throw new Error('attempt stream missing after get-or-create');
+    if (row.workspaceId !== identity.workspaceId || row.projectId !== identity.projectId || row.workflowRunAttemptId !== identity.workflowRunAttemptId) {
+        throw new LeaseStreamMismatchError();
+    }
+    return {
+        stream: toAttemptStream(row),
+        created: row.created
+    };
+}
+export async function getOrCreateAttemptStream(tx, identity) {
+    const result = await getOrCreateAttemptStreamWithStatus(tx, identity);
+    return result.stream;
+}
+/**
+ * Offset-CAS extend: advances `committed_length` by `byteLen` iff it currently
+ * equals `offset`. On mismatch, re-reads the committed length and classifies the
+ * caller's chunk: a retry (fully already applied) only when `offset + byteLen`
+ * does not run past the committed length; otherwise a gap. A chunk that straddles
+ * the committed point (offset behind it, but extending past it) is a gap too, so
+ * the runner rewinds rather than getting a 200 that silently drops its tail.
+ */ export async function casExtendCommittedLength(tx, params) {
+    const extended = await tx.update(attemptStreams).set({
+        committedLength: sql`${attemptStreams.committedLength} + ${params.byteLen}`,
+        updatedAt: sql`now()`
+    }).where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.committedLength, params.offset))).returning({
+        committedLength: attemptStreams.committedLength
+    });
+    if (extended[0]) return {
+        outcome: 'extended',
+        committedLength: extended[0].committedLength
+    };
+    const [current] = await tx.select({
+        committedLength: attemptStreams.committedLength
+    }).from(attemptStreams).where(eq(attemptStreams.id, params.streamId));
+    const committedLength = current?.committedLength ?? 0;
+    const fullyApplied = params.offset + params.byteLen <= committedLength;
+    return {
+        outcome: fullyApplied ? 'retry' : 'gap',
+        committedLength
+    };
+}
+export async function setDeclaredTotalBytes(tx, params) {
+    await tx.update(attemptStreams).set({
+        declaredTotalBytes: params.declaredTotalBytes,
+        updatedAt: sql`now()`
+    }).where(eq(attemptStreams.id, params.streamId));
+}
+/**
+ * Guarded close: flips `open → closed` and stamps `closed_at` iff the stream is
+ * still open, returning the closed row (or null when another path already closed
+ * it). The `WHERE state='open'` predicate is both the row lock and the
+ * exactly-once gate. `committed_length` is left untouched; it stays equal to the
+ * runner spool bytes. `truncated` is set only on the timeout path.
+ */ export async function markStreamClosed(tx, params) {
+    const [row] = await tx.update(attemptStreams).set({
+        state: 'closed',
+        closeReason: params.reason,
+        closedAt: sql`now()`,
+        updatedAt: sql`now()`,
+        ...params.markTruncated ? {
+            truncated: true
+        } : {}
+    }).where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.state, 'open'))).returning();
+    return row ? toAttemptStream(row) : null;
+}
+/** Open streams of a job, for the timeout sweep to force-close after the grace period. */ export async function listOpenStreamsByJob(jobId) {
+    const rows = await db().select().from(attemptStreams).where(and(eq(attemptStreams.jobId, jobId), eq(attemptStreams.state, 'open')));
+    return rows.map(toAttemptStream);
+}
+/** For compaction, which is driven by the closed event that carries the stream id. */ export async function getAttemptStreamById(streamId) {
+    const [row] = await db().select().from(attemptStreams).where(eq(attemptStreams.id, streamId));
+    return row ? toAttemptStream(row) : null;
+}
+export async function getAttemptStreamByIdInTransaction(tx, streamId) {
+    const [row] = await tx.select().from(attemptStreams).where(eq(attemptStreams.id, streamId));
+    return row ? toAttemptStream(row) : null;
+}
+/**
+ * Final compaction step: records the object key and deletes the now-cold chunk rows in one
+ * transaction. The guard is `state='closed' AND object_key IS NULL`, so the publish is a
+ * single winner even when two compaction attempts (e.g. a heartbeat-timed-out run and its
+ * retry) race: each uploads to its own key, and only the first to land here writes a key and
+ * drops the chunks. A 0-row result means the row was either hard-deleted by retention or
+ * already published by another attempt; the caller re-reads to tell those apart and deletes
+ * its own now-orphaned upload either way. Returns whether this attempt won the publish.
+ */ export async function setObjectKeyAndDeleteChunks(tx, params) {
+    const updated = await tx.update(attemptStreams).set({
+        objectKey: params.objectKey,
+        updatedAt: sql`now()`
+    }).where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.state, 'closed'), isNull(attemptStreams.objectKey))).returning({
+        id: attemptStreams.id
+    });
+    if (updated.length === 0) return {
+        updated: false
+    };
+    await tx.delete(logChunks).where(eq(logChunks.streamId, params.streamId));
+    return {
+        updated: true
+    };
+}
+/**
+ * Closed streams that never got an object key and have sat that way past the stale
+ * window: the reconcile cron re-drives compaction for these. Hits the partial index
+ * `logs_attempt_streams_uncompacted_idx`; ordered by `closed_at` so the oldest backlog
+ * drains first, bounded by `limit` per tick.
+ */ export async function listStaleUncompactedStreams(params) {
+    const rows = await db().select().from(attemptStreams).where(and(eq(attemptStreams.state, 'closed'), isNull(attemptStreams.objectKey), lt(attemptStreams.closedAt, sql`now() - make_interval(secs => ${params.olderThanSeconds})`))).orderBy(asc(attemptStreams.closedAt)).limit(params.limit);
+    return rows.map(toAttemptStream);
+}
+/**
+ * Lists open streams old enough to force-close. The age check is safe only when
+ * `olderThanSeconds` exceeds the lease TTL: leases are minted before a stream can
+ * be created, so no valid append can arrive after `created_at + leaseTTL`.
+ */ export async function listStaleOpenStreams(params) {
+    const rows = await db().select().from(attemptStreams).where(and(eq(attemptStreams.state, 'open'), lt(attemptStreams.createdAt, sql`now() - make_interval(secs => ${params.olderThanSeconds})`))).orderBy(asc(attemptStreams.createdAt)).limit(params.limit);
+    return rows.map(toAttemptStream);
+}
+export async function getOpenStreamCount() {
+    const [row] = await db().select({
+        value: sql`count(*)`.mapWith(BigInt)
+    }).from(attemptStreams).where(eq(attemptStreams.state, 'open'));
+    return row?.value ?? 0n;
+}
+/**
+ * Lists expired closed streams for retention. `excludeIds` keeps failed or raced rows from
+ * starving younger rows in the same run, and avoids cursoring on `closed_at`, whose microsecond
+ * precision would be lost through JS `Date`.
+ *
+ * No `object_key` filter: retention deletes compacted and never-compacted streams alike.
+ */ export async function listExpiredClosedStreams(params) {
+    const rows = await db().select().from(attemptStreams).where(and(eq(attemptStreams.state, 'closed'), lt(attemptStreams.closedAt, sql`now() - make_interval(days => ${params.retentionDays})`), params.excludeIds && params.excludeIds.length > 0 ? notInArray(attemptStreams.id, params.excludeIds) : undefined)).orderBy(asc(attemptStreams.closedAt), asc(attemptStreams.id)).limit(params.limit).for('update', {
+        skipLocked: true
+    });
+    return rows.map(toAttemptStream);
+}
+/**
+ * Hard-deletes one expired stream row, guarded on the observed `object_key` so a racing
+ * compaction publish leaves the row for the next sweep.
+ */ export async function deleteExpiredStream(tx, params) {
+    const [row] = await tx.delete(attemptStreams).where(and(eq(attemptStreams.id, params.streamId), params.observedObjectKey === null ? isNull(attemptStreams.objectKey) : eq(attemptStreams.objectKey, params.observedObjectKey))).returning({
+        jobId: attemptStreams.jobId
+    });
+    return {
+        deleted: Boolean(row),
+        jobId: row?.jobId ?? null
+    };
+}
+export async function accountingHasNoStreams(tx, jobId) {
+    const [row] = await tx.select({
+        id: attemptStreams.id
+    }).from(attemptStreams).where(eq(attemptStreams.jobId, jobId)).limit(1);
+    return !row;
+}
+
+//# sourceMappingURL=streams.js.map

package/dist/db/streams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/streams.ts"],"sourcesContent":["import {and, asc, eq, getTableColumns, isNull, lt, notInArray, sql} from 'drizzle-orm';\nimport type {AttemptStream, StreamCloseReason} from '#core/entities/attempt-stream.js';\nimport {LeaseStreamMismatchError} from '#core/errors.js';\nimport {db, type Transaction} from './db.js';\nimport {attemptStreams, toAttemptStream} from './schema/attempt-streams.js';\nimport {logChunks} from './schema/chunks.js';\n\nexport interface AttemptStreamIdentity {\n  jobId: string;\n  stepId: string;\n  attempt: number;\n  workspaceId: string;\n  projectId: string;\n  workflowRunAttemptId: string;\n}\n\nexport interface AttemptStreamLookup {\n  jobId: string;\n  stepId: string;\n  attempt: number;\n}\n\n/**\n * Reads the stream for `(job, step, attempt)` without creating it. Used by the\n * empty-body heartbeat path so a runner cannot mint rows with empty appends.\n */\nexport async function getAttemptStream(\n  tx: Transaction,\n  lookup: AttemptStreamLookup,\n): Promise<AttemptStream | null> {\n  const [row] = await tx\n    .select()\n    .from(attemptStreams)\n    .where(\n      and(\n        eq(attemptStreams.jobId, lookup.jobId),\n        eq(attemptStreams.stepId, lookup.stepId),\n        eq(attemptStreams.attempt, lookup.attempt),\n      ),\n    );\n  return row ? toAttemptStream(row) : null;\n}\n\n/**\n * Reads the stream for `(step, attempt)` for the session read path, which holds no lease\n * and so has no `jobId`. `stepId` is a globally unique uuidv7, so `(stepId, attempt)`\n * selects at most one row even though stream identity is `(jobId, stepId, attempt)`. The\n * caller authorizes against the row's denormalized `workspaceId`.\n */\nexport async function getStreamByStepAttempt(lookup: {\n  stepId: string;\n  attempt: number;\n}): Promise<AttemptStream | null> {\n  const [row] = await db()\n    .select()\n    .from(attemptStreams)\n    .where(\n      and(eq(attemptStreams.stepId, lookup.stepId), eq(attemptStreams.attempt, lookup.attempt)),\n    );\n  return row ? toAttemptStream(row) : null;\n}\n\nexport interface GetOrCreateAttemptStreamResult {\n  stream: AttemptStream;\n  created: boolean;\n}\n\n/**\n * Loads the stream for `(job, step, attempt)`, creating it on first append.\n * Scoped by `jobId` from the lease, so a lease never reaches another job's stream.\n * The create path reports whether the row was inserted so callers can record\n * first-open side effects only after their enclosing transaction commits.\n */\nexport async function getOrCreateAttemptStreamWithStatus(\n  tx: Transaction,\n  identity: AttemptStreamIdentity,\n): Promise<GetOrCreateAttemptStreamResult> {\n  const [row] = await tx\n    .insert(attemptStreams)\n    .values(identity)\n    .onConflictDoUpdate({\n      target: [attemptStreams.jobId, attemptStreams.stepId, attemptStreams.attempt],\n      set: {updatedAt: sql`now()`},\n    })\n    // Postgres sets `xmax` only on the conflict-update path, so this keeps\n    // first-open detection in the single upsert round trip.\n    .returning({...getTableColumns(attemptStreams), created: sql<boolean>`xmax = 0`});\n\n  if (!row) throw new Error('attempt stream missing after get-or-create');\n  if (\n    row.workspaceId !== identity.workspaceId ||\n    row.projectId !== identity.projectId ||\n    row.workflowRunAttemptId !== identity.workflowRunAttemptId\n  ) {\n    throw new LeaseStreamMismatchError();\n  }\n  return {stream: toAttemptStream(row), created: row.created};\n}\n\nexport async function getOrCreateAttemptStream(\n  tx: Transaction,\n  identity: AttemptStreamIdentity,\n): Promise<AttemptStream> {\n  const result = await getOrCreateAttemptStreamWithStatus(tx, identity);\n  return result.stream;\n}\n\nexport type CasOutcome = 'extended' | 'retry' | 'gap';\n\nexport interface CasResult {\n  outcome: CasOutcome;\n  committedLength: number;\n}\n\n/**\n * Offset-CAS extend: advances `committed_length` by `byteLen` iff it currently\n * equals `offset`. On mismatch, re-reads the committed length and classifies the\n * caller's chunk: a retry (fully already applied) only when `offset + byteLen`\n * does not run past the committed length; otherwise a gap. A chunk that straddles\n * the committed point (offset behind it, but extending past it) is a gap too, so\n * the runner rewinds rather than getting a 200 that silently drops its tail.\n */\nexport async function casExtendCommittedLength(\n  tx: Transaction,\n  params: {streamId: string; offset: number; byteLen: number},\n): Promise<CasResult> {\n  const extended = await tx\n    .update(attemptStreams)\n    .set({\n      committedLength: sql`${attemptStreams.committedLength} + ${params.byteLen}`,\n      updatedAt: sql`now()`,\n    })\n    .where(\n      and(\n        eq(attemptStreams.id, params.streamId),\n        eq(attemptStreams.committedLength, params.offset),\n      ),\n    )\n    .returning({committedLength: attemptStreams.committedLength});\n\n  if (extended[0]) return {outcome: 'extended', committedLength: extended[0].committedLength};\n\n  const [current] = await tx\n    .select({committedLength: attemptStreams.committedLength})\n    .from(attemptStreams)\n    .where(eq(attemptStreams.id, params.streamId));\n  const committedLength = current?.committedLength ?? 0;\n\n  const fullyApplied = params.offset + params.byteLen <= committedLength;\n  return {outcome: fullyApplied ? 'retry' : 'gap', committedLength};\n}\n\nexport async function setDeclaredTotalBytes(\n  tx: Transaction,\n  params: {streamId: string; declaredTotalBytes: number},\n): Promise<void> {\n  await tx\n    .update(attemptStreams)\n    .set({declaredTotalBytes: params.declaredTotalBytes, updatedAt: sql`now()`})\n    .where(eq(attemptStreams.id, params.streamId));\n}\n\n/**\n * Guarded close: flips `open → closed` and stamps `closed_at` iff the stream is\n * still open, returning the closed row (or null when another path already closed\n * it). The `WHERE state='open'` predicate is both the row lock and the\n * exactly-once gate. `committed_length` is left untouched; it stays equal to the\n * runner spool bytes. `truncated` is set only on the timeout path.\n */\nexport async function markStreamClosed(\n  tx: Transaction,\n  params: {streamId: string; reason: StreamCloseReason; markTruncated: boolean},\n): Promise<AttemptStream | null> {\n  const [row] = await tx\n    .update(attemptStreams)\n    .set({\n      state: 'closed',\n      closeReason: params.reason,\n      closedAt: sql`now()`,\n      updatedAt: sql`now()`,\n      ...(params.markTruncated ? {truncated: true} : {}),\n    })\n    .where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.state, 'open')))\n    .returning();\n\n  return row ? toAttemptStream(row) : null;\n}\n\n/** Open streams of a job, for the timeout sweep to force-close after the grace period. */\nexport async function listOpenStreamsByJob(jobId: string): Promise<AttemptStream[]> {\n  const rows = await db()\n    .select()\n    .from(attemptStreams)\n    .where(and(eq(attemptStreams.jobId, jobId), eq(attemptStreams.state, 'open')));\n\n  return rows.map(toAttemptStream);\n}\n\n/** For compaction, which is driven by the closed event that carries the stream id. */\nexport async function getAttemptStreamById(streamId: string): Promise<AttemptStream | null> {\n  const [row] = await db().select().from(attemptStreams).where(eq(attemptStreams.id, streamId));\n  return row ? toAttemptStream(row) : null;\n}\n\nexport async function getAttemptStreamByIdInTransaction(\n  tx: Transaction,\n  streamId: string,\n): Promise<AttemptStream | null> {\n  const [row] = await tx.select().from(attemptStreams).where(eq(attemptStreams.id, streamId));\n  return row ? toAttemptStream(row) : null;\n}\n\n/**\n * Final compaction step: records the object key and deletes the now-cold chunk rows in one\n * transaction. The guard is `state='closed' AND object_key IS NULL`, so the publish is a\n * single winner even when two compaction attempts (e.g. a heartbeat-timed-out run and its\n * retry) race: each uploads to its own key, and only the first to land here writes a key and\n * drops the chunks. A 0-row result means the row was either hard-deleted by retention or\n * already published by another attempt; the caller re-reads to tell those apart and deletes\n * its own now-orphaned upload either way. Returns whether this attempt won the publish.\n */\nexport async function setObjectKeyAndDeleteChunks(\n  tx: Transaction,\n  params: {streamId: string; objectKey: string},\n): Promise<{updated: boolean}> {\n  const updated = await tx\n    .update(attemptStreams)\n    .set({objectKey: params.objectKey, updatedAt: sql`now()`})\n    .where(\n      and(\n        eq(attemptStreams.id, params.streamId),\n        eq(attemptStreams.state, 'closed'),\n        isNull(attemptStreams.objectKey),\n      ),\n    )\n    .returning({id: attemptStreams.id});\n\n  if (updated.length === 0) return {updated: false};\n\n  await tx.delete(logChunks).where(eq(logChunks.streamId, params.streamId));\n  return {updated: true};\n}\n\n/**\n * Closed streams that never got an object key and have sat that way past the stale\n * window: the reconcile cron re-drives compaction for these. Hits the partial index\n * `logs_attempt_streams_uncompacted_idx`; ordered by `closed_at` so the oldest backlog\n * drains first, bounded by `limit` per tick.\n */\nexport async function listStaleUncompactedStreams(params: {\n  olderThanSeconds: number;\n  limit: number;\n}): Promise<AttemptStream[]> {\n  const rows = await db()\n    .select()\n    .from(attemptStreams)\n    .where(\n      and(\n        eq(attemptStreams.state, 'closed'),\n        isNull(attemptStreams.objectKey),\n        lt(attemptStreams.closedAt, sql`now() - make_interval(secs => ${params.olderThanSeconds})`),\n      ),\n    )\n    .orderBy(asc(attemptStreams.closedAt))\n    .limit(params.limit);\n\n  return rows.map(toAttemptStream);\n}\n\n/**\n * Lists open streams old enough to force-close. The age check is safe only when\n * `olderThanSeconds` exceeds the lease TTL: leases are minted before a stream can\n * be created, so no valid append can arrive after `created_at + leaseTTL`.\n */\nexport async function listStaleOpenStreams(params: {\n  olderThanSeconds: number;\n  limit: number;\n}): Promise<AttemptStream[]> {\n  const rows = await db()\n    .select()\n    .from(attemptStreams)\n    .where(\n      and(\n        eq(attemptStreams.state, 'open'),\n        lt(\n          attemptStreams.createdAt,\n          sql`now() - make_interval(secs => ${params.olderThanSeconds})`,\n        ),\n      ),\n    )\n    .orderBy(asc(attemptStreams.createdAt))\n    .limit(params.limit);\n\n  return rows.map(toAttemptStream);\n}\n\nexport async function getOpenStreamCount(): Promise<bigint> {\n  const [row] = await db()\n    .select({value: sql<bigint>`count(*)`.mapWith(BigInt)})\n    .from(attemptStreams)\n    .where(eq(attemptStreams.state, 'open'));\n\n  return row?.value ?? 0n;\n}\n\n/**\n * Lists expired closed streams for retention. `excludeIds` keeps failed or raced rows from\n * starving younger rows in the same run, and avoids cursoring on `closed_at`, whose microsecond\n * precision would be lost through JS `Date`.\n *\n * No `object_key` filter: retention deletes compacted and never-compacted streams alike.\n */\nexport async function listExpiredClosedStreams(params: {\n  retentionDays: number;\n  limit: number;\n  excludeIds?: string[] | undefined;\n}): Promise<AttemptStream[]> {\n  const rows = await db()\n    .select()\n    .from(attemptStreams)\n    .where(\n      and(\n        eq(attemptStreams.state, 'closed'),\n        lt(attemptStreams.closedAt, sql`now() - make_interval(days => ${params.retentionDays})`),\n        params.excludeIds && params.excludeIds.length > 0\n          ? notInArray(attemptStreams.id, params.excludeIds)\n          : undefined,\n      ),\n    )\n    .orderBy(asc(attemptStreams.closedAt), asc(attemptStreams.id))\n    .limit(params.limit)\n    .for('update', {skipLocked: true});\n\n  return rows.map(toAttemptStream);\n}\n\n/**\n * Hard-deletes one expired stream row, guarded on the observed `object_key` so a racing\n * compaction publish leaves the row for the next sweep.\n */\nexport async function deleteExpiredStream(\n  tx: Transaction,\n  params: {streamId: string; observedObjectKey: string | null},\n): Promise<{deleted: boolean; jobId: string | null}> {\n  const [row] = await tx\n    .delete(attemptStreams)\n    .where(\n      and(\n        eq(attemptStreams.id, params.streamId),\n        params.observedObjectKey === null\n          ? isNull(attemptStreams.objectKey)\n          : eq(attemptStreams.objectKey, params.observedObjectKey),\n      ),\n    )\n    .returning({jobId: attemptStreams.jobId});\n\n  return {deleted: Boolean(row), jobId: row?.jobId ?? null};\n}\n\nexport async function accountingHasNoStreams(tx: Transaction, jobId: string): Promise<boolean> {\n  const [row] = await tx\n    .select({id: attemptStreams.id})\n    .from(attemptStreams)\n    .where(eq(attemptStreams.jobId, jobId))\n    .limit(1);\n\n  return !row;\n}\n"],"names":["and","asc","eq","getTableColumns","isNull","lt","notInArray","sql","LeaseStreamMismatchError","db","attemptStreams","toAttemptStream","logChunks","getAttemptStream","tx","lookup","row","select","from","where","jobId","stepId","attempt","getStreamByStepAttempt","getOrCreateAttemptStreamWithStatus","identity","insert","values","onConflictDoUpdate","target","set","updatedAt","returning","created","Error","workspaceId","projectId","workflowRunAttemptId","stream","getOrCreateAttemptStream","result","casExtendCommittedLength","params","extended","update","committedLength","byteLen","id","streamId","offset","outcome","current","fullyApplied","setDeclaredTotalBytes","declaredTotalBytes","markStreamClosed","state","closeReason","reason","closedAt","markTruncated","truncated","listOpenStreamsByJob","rows","map","getAttemptStreamById","getAttemptStreamByIdInTransaction","setObjectKeyAndDeleteChunks","updated","objectKey","length","delete","listStaleUncompactedStreams","olderThanSeconds","orderBy","limit","listStaleOpenStreams","createdAt","getOpenStreamCount","value","mapWith","BigInt","listExpiredClosedStreams","retentionDays","excludeIds","undefined","for","skipLocked","deleteExpiredStream","observedObjectKey","deleted","Boolean","accountingHasNoStreams"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { type ShipfoxModule } from '@shipfox/node-module';
+export { checkBucketReachable } from '#api/object-storage.js';
+export declare const logsModule: ShipfoxModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,KAAK,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AAY3E,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAO5D,eAAO,MAAM,UAAU,EAAE,aAiDxB,CAAC"}

package/dist/index.js

@@ -0,0 +1,81 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LOG_STREAM_CLOSED, logsEventSchemas } from '@shipfox/api-logs-dto';
+import { WORKFLOWS_JOB_TERMINATED, WORKFLOWS_STEP_ATTEMPT_TERMINATED } from '@shipfox/api-workflows-dto';
+import { subscriberFactory } from '@shipfox/node-module';
+import { db } from '#db/db.js';
+import { migrationsPath } from '#db/index.js';
+import { logsOutbox } from '#db/schema/outbox.js';
+import { registerLogsServiceMetrics } from '#metrics/service.js';
+import { logsRoutes } from '#presentation/routes/index.js';
+import { onJobTerminated } from '#presentation/subscribers/on-job-terminated.js';
+import { onLogStreamClosed } from '#presentation/subscribers/on-log-stream-closed.js';
+import { onStepAttemptTerminated } from '#presentation/subscribers/on-step-attempt-terminated.js';
+import { createLogsActivities } from '#temporal/activities/index.js';
+import { LOGS_COMPACTION_TASK_QUEUE, LOGS_LIFECYCLE_TASK_QUEUE } from '#temporal/constants.js';
+export { checkBucketReachable } from '#api/object-storage.js';
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
+const subscriber = subscriberFactory();
+export const logsModule = {
+    name: 'logs',
+    database: {
+        db,
+        migrationsPath
+    },
+    routes: logsRoutes,
+    metrics: registerLogsServiceMetrics,
+    // `logs.stream.closed` is written by the close paths: the job-terminated subscriber
+    // force-closes streams the runner never ended, and the closed event drives compaction.
+    publishers: [
+        {
+            name: 'logs',
+            table: logsOutbox,
+            db,
+            eventSchemas: logsEventSchemas
+        }
+    ],
+    subscribers: [
+        subscriber(WORKFLOWS_STEP_ATTEMPT_TERMINATED, onStepAttemptTerminated),
+        subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminated),
+        subscriber(LOG_STREAM_CLOSED, onLogStreamClosed)
+    ],
+    workers: [
+        {
+            taskQueue: LOGS_LIFECYCLE_TASK_QUEUE,
+            workflowsPath,
+            activities: createLogsActivities,
+            // Temporal cron schedules are fixed after creation, so making cadence configurable would
+            // look adjustable while keeping the old schedule. Tune LOG_RETENTION_DAYS for the horizon.
+            workflows: [
+                {
+                    name: 'retentionSweepCron',
+                    id: 'logs-retention-sweep',
+                    cronSchedule: '0 * * * *'
+                },
+                // Offset from retention's top-of-hour sweep; stale-stream age is governed by
+                // LOG_STREAM_REAP_AFTER_SECONDS.
+                {
+                    name: 'reapStaleOpenStreamsCron',
+                    id: 'logs-reap-stale-open-streams',
+                    cronSchedule: '5,15,25,35,45,55 * * * *'
+                }
+            ]
+        },
+        // Compaction runs on its own queue so long uploads cannot starve the lifecycle sweep.
+        {
+            taskQueue: LOGS_COMPACTION_TASK_QUEUE,
+            workflowsPath,
+            activities: createLogsActivities,
+            workflows: [
+                {
+                    name: 'compactionReconcileCron',
+                    id: 'logs-compaction-reconcile',
+                    cronSchedule: '*/10 * * * *'
+                }
+            ]
+        }
+    ]
+};
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport {LOG_STREAM_CLOSED, type LogsEventMap, logsEventSchemas} from '@shipfox/api-logs-dto';\nimport {\n  WORKFLOWS_JOB_TERMINATED,\n  WORKFLOWS_STEP_ATTEMPT_TERMINATED,\n  type WorkflowsEventMapDto,\n} from '@shipfox/api-workflows-dto';\nimport {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';\nimport {db} from '#db/db.js';\nimport {migrationsPath} from '#db/index.js';\nimport {logsOutbox} from '#db/schema/outbox.js';\nimport {registerLogsServiceMetrics} from '#metrics/service.js';\nimport {logsRoutes} from '#presentation/routes/index.js';\nimport {onJobTerminated} from '#presentation/subscribers/on-job-terminated.js';\nimport {onLogStreamClosed} from '#presentation/subscribers/on-log-stream-closed.js';\nimport {onStepAttemptTerminated} from '#presentation/subscribers/on-step-attempt-terminated.js';\nimport {createLogsActivities} from '#temporal/activities/index.js';\nimport {LOGS_COMPACTION_TASK_QUEUE, LOGS_LIFECYCLE_TASK_QUEUE} from '#temporal/constants.js';\n\nexport {checkBucketReachable} from '#api/object-storage.js';\n\nconst packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');\nconst workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');\n\nconst subscriber = subscriberFactory<WorkflowsEventMapDto & LogsEventMap>();\n\nexport const logsModule: ShipfoxModule = {\n  name: 'logs',\n  database: {db, migrationsPath},\n  routes: logsRoutes,\n  metrics: registerLogsServiceMetrics,\n  // `logs.stream.closed` is written by the close paths: the job-terminated subscriber\n  // force-closes streams the runner never ended, and the closed event drives compaction.\n  publishers: [{name: 'logs', table: logsOutbox, db, eventSchemas: logsEventSchemas}],\n  subscribers: [\n    subscriber(WORKFLOWS_STEP_ATTEMPT_TERMINATED, onStepAttemptTerminated),\n    subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminated),\n    subscriber(LOG_STREAM_CLOSED, onLogStreamClosed),\n  ],\n  workers: [\n    {\n      taskQueue: LOGS_LIFECYCLE_TASK_QUEUE,\n      workflowsPath,\n      activities: createLogsActivities,\n      // Temporal cron schedules are fixed after creation, so making cadence configurable would\n      // look adjustable while keeping the old schedule. Tune LOG_RETENTION_DAYS for the horizon.\n      workflows: [\n        {\n          name: 'retentionSweepCron',\n          id: 'logs-retention-sweep',\n          cronSchedule: '0 * * * *',\n        },\n        // Offset from retention's top-of-hour sweep; stale-stream age is governed by\n        // LOG_STREAM_REAP_AFTER_SECONDS.\n        {\n          name: 'reapStaleOpenStreamsCron',\n          id: 'logs-reap-stale-open-streams',\n          cronSchedule: '5,15,25,35,45,55 * * * *',\n        },\n      ],\n    },\n    // Compaction runs on its own queue so long uploads cannot starve the lifecycle sweep.\n    {\n      taskQueue: LOGS_COMPACTION_TASK_QUEUE,\n      workflowsPath,\n      activities: createLogsActivities,\n      workflows: [\n        {\n          name: 'compactionReconcileCron',\n          id: 'logs-compaction-reconcile',\n          cronSchedule: '*/10 * * * *',\n        },\n      ],\n    },\n  ],\n};\n"],"names":["dirname","resolve","fileURLToPath","LOG_STREAM_CLOSED","logsEventSchemas","WORKFLOWS_JOB_TERMINATED","WORKFLOWS_STEP_ATTEMPT_TERMINATED","subscriberFactory","db","migrationsPath","logsOutbox","registerLogsServiceMetrics","logsRoutes","onJobTerminated","onLogStreamClosed","onStepAttemptTerminated","createLogsActivities","LOGS_COMPACTION_TASK_QUEUE","LOGS_LIFECYCLE_TASK_QUEUE","checkBucketReachable","packageRoot","url","workflowsPath","subscriber","logsModule","name","database","routes","metrics","publishers","table","eventSchemas","subscribers","workers","taskQueue","activities","workflows","id","cronSchedule"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AACvC,SAAQC,iBAAiB,EAAqBC,gBAAgB,QAAO,wBAAwB;AAC7F,SACEC,wBAAwB,EACxBC,iCAAiC,QAE5B,6BAA6B;AACpC,SAA4BC,iBAAiB,QAAO,uBAAuB;AAC3E,SAAQC,EAAE,QAAO,YAAY;AAC7B,SAAQC,cAAc,QAAO,eAAe;AAC5C,SAAQC,UAAU,QAAO,uBAAuB;AAChD,SAAQC,0BAA0B,QAAO,sBAAsB;AAC/D,SAAQC,UAAU,QAAO,gCAAgC;AACzD,SAAQC,eAAe,QAAO,iDAAiD;AAC/E,SAAQC,iBAAiB,QAAO,oDAAoD;AACpF,SAAQC,uBAAuB,QAAO,0DAA0D;AAChG,SAAQC,oBAAoB,QAAO,gCAAgC;AACnE,SAAQC,0BAA0B,EAAEC,yBAAyB,QAAO,yBAAyB;AAE7F,SAAQC,oBAAoB,QAAO,yBAAyB;AAE5D,MAAMC,cAAcnB,QAAQD,QAAQE,cAAc,YAAYmB,GAAG,IAAI;AACrE,MAAMC,gBAAgBrB,QAAQmB,aAAa;AAE3C,MAAMG,aAAahB;AAEnB,OAAO,MAAMiB,aAA4B;IACvCC,MAAM;IACNC,UAAU;QAAClB;QAAIC;IAAc;IAC7BkB,QAAQf;IACRgB,SAASjB;IACT,oFAAoF;IACpF,uFAAuF;IACvFkB,YAAY;QAAC;YAACJ,MAAM;YAAQK,OAAOpB;YAAYF;YAAIuB,cAAc3B;QAAgB;KAAE;IACnF4B,aAAa;QACXT,WAAWjB,mCAAmCS;QAC9CQ,WAAWlB,0BAA0BQ;QACrCU,WAAWpB,mBAAmBW;KAC/B;IACDmB,SAAS;QACP;YACEC,WAAWhB;YACXI;YACAa,YAAYnB;YACZ,yFAAyF;YACzF,2FAA2F;YAC3FoB,WAAW;gBACT;oBACEX,MAAM;oBACNY,IAAI;oBACJC,cAAc;gBAChB;gBACA,6EAA6E;gBAC7E,iCAAiC;gBACjC;oBACEb,MAAM;oBACNY,IAAI;oBACJC,cAAc;gBAChB;aACD;QACH;QACA,sFAAsF;QACtF;YACEJ,WAAWjB;YACXK;YACAa,YAAYnB;YACZoB,WAAW;gBACT;oBACEX,MAAM;oBACNY,IAAI;oBACJC,cAAc;gBAChB;aACD;QACH;KACD;AACH,EAAE"}

package/dist/metrics/index.d.ts

@@ -0,0 +1,2 @@
+export { registerLogsServiceMetrics } from './service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/metrics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/metrics/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,0BAA0B,EAAC,MAAM,cAAc,CAAC"}

package/dist/metrics/index.js

@@ -0,0 +1,3 @@
+export { registerLogsServiceMetrics } from './service.js';
+
+//# sourceMappingURL=index.js.map

package/dist/metrics/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metrics/index.ts"],"sourcesContent":["export {registerLogsServiceMetrics} from './service.js';\n"],"names":["registerLogsServiceMetrics"],"mappings":"AAAA,SAAQA,0BAA0B,QAAO,eAAe"}

package/dist/metrics/instance.d.ts

@@ -0,0 +1,14 @@
+import type { LogRecord } from '@shipfox/api-logs-dto';
+export type LogRecordMetricKind = LogRecord['type'];
+export declare const recordAppendedCount: import("@shipfox/node-opentelemetry").Counter<{
+    kind: LogRecordMetricKind;
+}>;
+export declare const streamOpenedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export declare const streamClosedCount: import("@shipfox/node-opentelemetry").Counter<{
+    reason: "declared" | "timeout";
+}>;
+export type CompactionMetricOutcome = 'already-compacted' | 'compacted' | 'failed' | 'gone' | 'retention-raced' | 'superseded';
+export declare const compactionCount: import("@shipfox/node-opentelemetry").Counter<{
+    outcome: CompactionMetricOutcome;
+}>;
+//# sourceMappingURL=instance.d.ts.map

package/dist/metrics/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/metrics/instance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAKrD,MAAM,MAAM,mBAAmB,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAEpD,eAAO,MAAM,mBAAmB;UAA8B,mBAAmB;EAGhF,CAAC;AAEF,eAAO,MAAM,iBAAiB,sEAE5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;YAAgC,UAAU,GAAG,SAAS;EAGnF,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAC/B,mBAAmB,GACnB,WAAW,GACX,QAAQ,GACR,MAAM,GACN,iBAAiB,GACjB,YAAY,CAAC;AAEjB,eAAO,MAAM,eAAe;aAAiC,uBAAuB;EAGnF,CAAC"}

package/dist/metrics/instance.js

@@ -0,0 +1,16 @@
+import { instanceMetrics } from '@shipfox/node-opentelemetry';
+const meter = instanceMetrics.getMeter('logs');
+export const recordAppendedCount = meter.createCounter('logs_record_appended', {
+    description: 'Log records appended to durable stream storage by record type'
+});
+export const streamOpenedCount = meter.createCounter('logs_stream_opened', {
+    description: 'Log streams opened by first append'
+});
+export const streamClosedCount = meter.createCounter('logs_stream_closed', {
+    description: 'Log streams closed by reason'
+});
+export const compactionCount = meter.createCounter('logs_compaction', {
+    description: 'Log stream compaction attempts by outcome'
+});
+
+//# sourceMappingURL=instance.js.map

package/dist/metrics/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metrics/instance.ts"],"sourcesContent":["import type {LogRecord} from '@shipfox/api-logs-dto';\nimport {instanceMetrics} from '@shipfox/node-opentelemetry';\n\nconst meter = instanceMetrics.getMeter('logs');\n\nexport type LogRecordMetricKind = LogRecord['type'];\n\nexport const recordAppendedCount = meter.createCounter<{kind: LogRecordMetricKind}>(\n  'logs_record_appended',\n  {description: 'Log records appended to durable stream storage by record type'},\n);\n\nexport const streamOpenedCount = meter.createCounter<Record<string, never>>('logs_stream_opened', {\n  description: 'Log streams opened by first append',\n});\n\nexport const streamClosedCount = meter.createCounter<{reason: 'declared' | 'timeout'}>(\n  'logs_stream_closed',\n  {description: 'Log streams closed by reason'},\n);\n\nexport type CompactionMetricOutcome =\n  | 'already-compacted'\n  | 'compacted'\n  | 'failed'\n  | 'gone'\n  | 'retention-raced'\n  | 'superseded';\n\nexport const compactionCount = meter.createCounter<{outcome: CompactionMetricOutcome}>(\n  'logs_compaction',\n  {description: 'Log stream compaction attempts by outcome'},\n);\n"],"names":["instanceMetrics","meter","getMeter","recordAppendedCount","createCounter","description","streamOpenedCount","streamClosedCount","compactionCount"],"mappings":"AACA,SAAQA,eAAe,QAAO,8BAA8B;AAE5D,MAAMC,QAAQD,gBAAgBE,QAAQ,CAAC;AAIvC,OAAO,MAAMC,sBAAsBF,MAAMG,aAAa,CACpD,wBACA;IAACC,aAAa;AAA+D,GAC7E;AAEF,OAAO,MAAMC,oBAAoBL,MAAMG,aAAa,CAAwB,sBAAsB;IAChGC,aAAa;AACf,GAAG;AAEH,OAAO,MAAME,oBAAoBN,MAAMG,aAAa,CAClD,sBACA;IAACC,aAAa;AAA8B,GAC5C;AAUF,OAAO,MAAMG,kBAAkBP,MAAMG,aAAa,CAChD,mBACA;IAACC,aAAa;AAA2C,GACzD"}

package/dist/metrics/service.d.ts

@@ -0,0 +1,2 @@
+export declare function registerLogsServiceMetrics(): void;
+//# sourceMappingURL=service.d.ts.map

package/dist/metrics/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/metrics/service.ts"],"names":[],"mappings":"AAGA,wBAAgB,0BAA0B,IAAI,IAAI,CAajD"}

package/dist/metrics/service.js

@@ -0,0 +1,20 @@
+import { getServiceMetricsProvider } from '@shipfox/node-opentelemetry';
+import { getOpenStreamCount } from '#db/streams.js';
+export function registerLogsServiceMetrics() {
+    const meter = getServiceMetricsProvider().getMeter('logs');
+    const openStreams = meter.createObservableGauge('logs_open_streams', {
+        description: 'Log streams currently open for appends'
+    });
+    meter.addBatchObservableCallback(async (observer)=>{
+        observer.observe(openStreams, toSafeGaugeNumber(await getOpenStreamCount()));
+    }, [
+        openStreams
+    ]);
+}
+function toSafeGaugeNumber(value) {
+    // OpenTelemetry gauges accept numbers; clamp unrepresentable DB counts rather than round them.
+    if (value <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(value);
+    return Number.MAX_SAFE_INTEGER;
+}
+
+//# sourceMappingURL=service.js.map

package/dist/metrics/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metrics/service.ts"],"sourcesContent":["import {getServiceMetricsProvider} from '@shipfox/node-opentelemetry';\nimport {getOpenStreamCount} from '#db/streams.js';\n\nexport function registerLogsServiceMetrics(): void {\n  const meter = getServiceMetricsProvider().getMeter('logs');\n\n  const openStreams = meter.createObservableGauge('logs_open_streams', {\n    description: 'Log streams currently open for appends',\n  });\n\n  meter.addBatchObservableCallback(\n    async (observer) => {\n      observer.observe(openStreams, toSafeGaugeNumber(await getOpenStreamCount()));\n    },\n    [openStreams],\n  );\n}\n\nfunction toSafeGaugeNumber(value: bigint): number {\n  // OpenTelemetry gauges accept numbers; clamp unrepresentable DB counts rather than round them.\n  if (value <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(value);\n  return Number.MAX_SAFE_INTEGER;\n}\n"],"names":["getServiceMetricsProvider","getOpenStreamCount","registerLogsServiceMetrics","meter","getMeter","openStreams","createObservableGauge","description","addBatchObservableCallback","observer","observe","toSafeGaugeNumber","value","BigInt","Number","MAX_SAFE_INTEGER"],"mappings":"AAAA,SAAQA,yBAAyB,QAAO,8BAA8B;AACtE,SAAQC,kBAAkB,QAAO,iBAAiB;AAElD,OAAO,SAASC;IACd,MAAMC,QAAQH,4BAA4BI,QAAQ,CAAC;IAEnD,MAAMC,cAAcF,MAAMG,qBAAqB,CAAC,qBAAqB;QACnEC,aAAa;IACf;IAEAJ,MAAMK,0BAA0B,CAC9B,OAAOC;QACLA,SAASC,OAAO,CAACL,aAAaM,kBAAkB,MAAMV;IACxD,GACA;QAACI;KAAY;AAEjB;AAEA,SAASM,kBAAkBC,KAAa;IACtC,+FAA+F;IAC/F,IAAIA,SAASC,OAAOC,OAAOC,gBAAgB,GAAG,OAAOD,OAAOF;IAC5D,OAAOE,OAAOC,gBAAgB;AAChC"}

package/dist/presentation/dto/read-logs.d.ts

@@ -0,0 +1,4 @@
+import type { ReadLogsResponseDto } from '@shipfox/api-logs-dto';
+import type { LogReadResult } from '#core/read-logs.js';
+export declare function toReadLogsDto(result: LogReadResult): ReadLogsResponseDto;
+//# sourceMappingURL=read-logs.d.ts.map

package/dist/presentation/dto/read-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-logs.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/read-logs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEtD,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,mBAAmB,CAoBxE"}

package/dist/presentation/dto/read-logs.js

@@ -0,0 +1,22 @@
+export function toReadLogsDto(result) {
+    if (result.mode === 'presigned') {
+        return {
+            mode: 'presigned',
+            url: result.url,
+            state: result.state,
+            expires_at: result.expiresAt.toISOString(),
+            total_bytes: result.totalBytes,
+            truncated: result.truncated
+        };
+    }
+    return {
+        mode: 'inline',
+        ndjson: result.ndjson,
+        next_cursor: result.nextCursor,
+        has_more: result.hasMore,
+        state: result.state,
+        truncated: result.truncated
+    };
+}
+
+//# sourceMappingURL=read-logs.js.map

package/dist/presentation/dto/read-logs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/dto/read-logs.ts"],"sourcesContent":["import type {ReadLogsResponseDto} from '@shipfox/api-logs-dto';\nimport type {LogReadResult} from '#core/read-logs.js';\n\nexport function toReadLogsDto(result: LogReadResult): ReadLogsResponseDto {\n  if (result.mode === 'presigned') {\n    return {\n      mode: 'presigned',\n      url: result.url,\n      state: result.state,\n      expires_at: result.expiresAt.toISOString(),\n      total_bytes: result.totalBytes,\n      truncated: result.truncated,\n    };\n  }\n\n  return {\n    mode: 'inline',\n    ndjson: result.ndjson,\n    next_cursor: result.nextCursor,\n    has_more: result.hasMore,\n    state: result.state,\n    truncated: result.truncated,\n  };\n}\n"],"names":["toReadLogsDto","result","mode","url","state","expires_at","expiresAt","toISOString","total_bytes","totalBytes","truncated","ndjson","next_cursor","nextCursor","has_more","hasMore"],"mappings":"AAGA,OAAO,SAASA,cAAcC,MAAqB;IACjD,IAAIA,OAAOC,IAAI,KAAK,aAAa;QAC/B,OAAO;YACLA,MAAM;YACNC,KAAKF,OAAOE,GAAG;YACfC,OAAOH,OAAOG,KAAK;YACnBC,YAAYJ,OAAOK,SAAS,CAACC,WAAW;YACxCC,aAAaP,OAAOQ,UAAU;YAC9BC,WAAWT,OAAOS,SAAS;QAC7B;IACF;IAEA,OAAO;QACLR,MAAM;QACNS,QAAQV,OAAOU,MAAM;QACrBC,aAAaX,OAAOY,UAAU;QAC9BC,UAAUb,OAAOc,OAAO;QACxBX,OAAOH,OAAOG,KAAK;QACnBM,WAAWT,OAAOS,SAAS;IAC7B;AACF"}

package/dist/presentation/routes/append-logs.d.ts

@@ -0,0 +1,2 @@
+export declare const appendLogsRoute: import("@shipfox/node-fastify").RouteDefinition;
+//# sourceMappingURL=append-logs.d.ts.map

package/dist/presentation/routes/append-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-logs.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/append-logs.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,eAAe,iDAqD1B,CAAC"}

package/dist/presentation/routes/append-logs.js

@@ -0,0 +1,71 @@
+import { Buffer } from 'node:buffer';
+import { requireLeasedJobContext } from '@shipfox/api-auth-context';
+import { appendLogsQuerySchema, appendLogsResponseSchema, offsetGapResponseSchema } from '@shipfox/api-logs-dto';
+import { ClientError, defineRoute } from '@shipfox/node-fastify';
+import { z } from 'zod';
+import { appendLogs } from '#core/append-logs.js';
+import { LeaseStreamMismatchError, MalformedLogChunkError, OffsetGapError } from '#core/errors.js';
+export const appendLogsRoute = defineRoute({
+    method: 'POST',
+    path: '/steps/:stepId/logs',
+    description: 'Append a chunk of logs for a step attempt of the leased job.',
+    schema: {
+        params: z.object({
+            stepId: z.string().uuid()
+        }),
+        querystring: appendLogsQuerySchema,
+        response: {
+            200: appendLogsResponseSchema,
+            409: offsetGapResponseSchema
+        }
+    },
+    errorHandler: (error)=>{
+        if (error instanceof OffsetGapError) {
+            throw new ClientError('Append offset is ahead of the committed length', 'offset-gap', {
+                status: 409,
+                details: {
+                    committed_length: error.committedLength
+                }
+            });
+        }
+        if (error instanceof MalformedLogChunkError) {
+            throw new ClientError(error.message, 'malformed-log-chunk', {
+                status: 400
+            });
+        }
+        if (error instanceof LeaseStreamMismatchError) {
+            throw new ClientError(error.message, 'lease-stream-mismatch', {
+                status: 403
+            });
+        }
+        throw error;
+    },
+    handler: async (request)=>{
+        const leasedJob = requireLeasedJobContext(request);
+        const { stepId } = request.params;
+        const { attempt, offset } = request.query;
+        // The scoped lease proves membership in the dispatched step attempt; active-step
+        // completion remains governed by workflow/report state, not the log append route.
+        if (leasedJob.currentStepId !== stepId || leasedJob.currentStepAttempt !== attempt) {
+            throw new ClientError('Step not found for leased job execution', 'step-not-found', {
+                status: 404
+            });
+        }
+        const result = await appendLogs({
+            jobId: leasedJob.jobId,
+            workspaceId: leasedJob.workspaceId,
+            projectId: leasedJob.projectId,
+            workflowRunAttemptId: leasedJob.workflowRunAttemptId,
+            stepId,
+            attempt,
+            offset,
+            body: request.body ?? Buffer.alloc(0)
+        });
+        return {
+            committed_length: result.committedLength,
+            capped: result.capped
+        };
+    }
+});
+
+//# sourceMappingURL=append-logs.js.map

package/dist/presentation/routes/append-logs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/append-logs.ts"],"sourcesContent":["import {Buffer} from 'node:buffer';\nimport {requireLeasedJobContext} from '@shipfox/api-auth-context';\nimport {\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  offsetGapResponseSchema,\n} from '@shipfox/api-logs-dto';\nimport {ClientError, defineRoute} from '@shipfox/node-fastify';\nimport {z} from 'zod';\nimport {appendLogs} from '#core/append-logs.js';\nimport {LeaseStreamMismatchError, MalformedLogChunkError, OffsetGapError} from '#core/errors.js';\n\nexport const appendLogsRoute = defineRoute({\n  method: 'POST',\n  path: '/steps/:stepId/logs',\n  description: 'Append a chunk of logs for a step attempt of the leased job.',\n  schema: {\n    params: z.object({stepId: z.string().uuid()}),\n    querystring: appendLogsQuerySchema,\n    response: {\n      200: appendLogsResponseSchema,\n      409: offsetGapResponseSchema,\n    },\n  },\n  errorHandler: (error) => {\n    if (error instanceof OffsetGapError) {\n      throw new ClientError('Append offset is ahead of the committed length', 'offset-gap', {\n        status: 409,\n        details: {committed_length: error.committedLength},\n      });\n    }\n    if (error instanceof MalformedLogChunkError) {\n      throw new ClientError(error.message, 'malformed-log-chunk', {status: 400});\n    }\n    if (error instanceof LeaseStreamMismatchError) {\n      throw new ClientError(error.message, 'lease-stream-mismatch', {status: 403});\n    }\n    throw error;\n  },\n  handler: async (request) => {\n    const leasedJob = requireLeasedJobContext(request);\n    const {stepId} = request.params;\n    const {attempt, offset} = request.query;\n\n    // The scoped lease proves membership in the dispatched step attempt; active-step\n    // completion remains governed by workflow/report state, not the log append route.\n    if (leasedJob.currentStepId !== stepId || leasedJob.currentStepAttempt !== attempt) {\n      throw new ClientError('Step not found for leased job execution', 'step-not-found', {\n        status: 404,\n      });\n    }\n\n    const result = await appendLogs({\n      jobId: leasedJob.jobId,\n      workspaceId: leasedJob.workspaceId,\n      projectId: leasedJob.projectId,\n      workflowRunAttemptId: leasedJob.workflowRunAttemptId,\n      stepId,\n      attempt,\n      offset,\n      body: (request.body as Buffer | undefined) ?? Buffer.alloc(0),\n    });\n\n    return {committed_length: result.committedLength, capped: result.capped};\n  },\n});\n"],"names":["Buffer","requireLeasedJobContext","appendLogsQuerySchema","appendLogsResponseSchema","offsetGapResponseSchema","ClientError","defineRoute","z","appendLogs","LeaseStreamMismatchError","MalformedLogChunkError","OffsetGapError","appendLogsRoute","method","path","description","schema","params","object","stepId","string","uuid","querystring","response","errorHandler","error","status","details","committed_length","committedLength","message","handler","request","leasedJob","attempt","offset","query","currentStepId","currentStepAttempt","result","jobId","workspaceId","projectId","workflowRunAttemptId","body","alloc","capped"],"mappings":"AAAA,SAAQA,MAAM,QAAO,cAAc;AACnC,SAAQC,uBAAuB,QAAO,4BAA4B;AAClE,SACEC,qBAAqB,EACrBC,wBAAwB,EACxBC,uBAAuB,QAClB,wBAAwB;AAC/B,SAAQC,WAAW,EAAEC,WAAW,QAAO,wBAAwB;AAC/D,SAAQC,CAAC,QAAO,MAAM;AACtB,SAAQC,UAAU,QAAO,uBAAuB;AAChD,SAAQC,wBAAwB,EAAEC,sBAAsB,EAAEC,cAAc,QAAO,kBAAkB;AAEjG,OAAO,MAAMC,kBAAkBN,YAAY;IACzCO,QAAQ;IACRC,MAAM;IACNC,aAAa;IACbC,QAAQ;QACNC,QAAQV,EAAEW,MAAM,CAAC;YAACC,QAAQZ,EAAEa,MAAM,GAAGC,IAAI;QAAE;QAC3CC,aAAapB;QACbqB,UAAU;YACR,KAAKpB;YACL,KAAKC;QACP;IACF;IACAoB,cAAc,CAACC;QACb,IAAIA,iBAAiBd,gBAAgB;YACnC,MAAM,IAAIN,YAAY,kDAAkD,cAAc;gBACpFqB,QAAQ;gBACRC,SAAS;oBAACC,kBAAkBH,MAAMI,eAAe;gBAAA;YACnD;QACF;QACA,IAAIJ,iBAAiBf,wBAAwB;YAC3C,MAAM,IAAIL,YAAYoB,MAAMK,OAAO,EAAE,uBAAuB;gBAACJ,QAAQ;YAAG;QAC1E;QACA,IAAID,iBAAiBhB,0BAA0B;YAC7C,MAAM,IAAIJ,YAAYoB,MAAMK,OAAO,EAAE,yBAAyB;gBAACJ,QAAQ;YAAG;QAC5E;QACA,MAAMD;IACR;IACAM,SAAS,OAAOC;QACd,MAAMC,YAAYhC,wBAAwB+B;QAC1C,MAAM,EAACb,MAAM,EAAC,GAAGa,QAAQf,MAAM;QAC/B,MAAM,EAACiB,OAAO,EAAEC,MAAM,EAAC,GAAGH,QAAQI,KAAK;QAEvC,iFAAiF;QACjF,kFAAkF;QAClF,IAAIH,UAAUI,aAAa,KAAKlB,UAAUc,UAAUK,kBAAkB,KAAKJ,SAAS;YAClF,MAAM,IAAI7B,YAAY,2CAA2C,kBAAkB;gBACjFqB,QAAQ;YACV;QACF;QAEA,MAAMa,SAAS,MAAM/B,WAAW;YAC9BgC,OAAOP,UAAUO,KAAK;YACtBC,aAAaR,UAAUQ,WAAW;YAClCC,WAAWT,UAAUS,SAAS;YAC9BC,sBAAsBV,UAAUU,oBAAoB;YACpDxB;YACAe;YACAC;YACAS,MAAM,AAACZ,QAAQY,IAAI,IAA2B5C,OAAO6C,KAAK,CAAC;QAC7D;QAEA,OAAO;YAACjB,kBAAkBW,OAAOV,eAAe;YAAEiB,QAAQP,OAAOO,MAAM;QAAA;IACzE;AACF,GAAG"}

package/dist/presentation/routes/index.d.ts

@@ -0,0 +1,3 @@
+import { type RouteGroup } from '@shipfox/node-fastify';
+export declare const logsRoutes: RouteGroup[];
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAQ3E,eAAO,MAAM,UAAU,EAAE,UAAU,EAiBlC,CAAC"}

package/dist/presentation/routes/index.js

@@ -0,0 +1,32 @@
+import { AUTH_LEASED_JOB, AUTH_USER } from '@shipfox/api-auth-context';
+import { createRawBodyPlugin } from '@shipfox/node-fastify';
+import { config } from '#config.js';
+import { appendLogsRoute } from './append-logs.js';
+import { readLogsRoute } from './read-logs.js';
+// Keep the lease-authed append in its own Fastify scope so the raw NDJSON parser does not
+// disturb the JSON read route (or workflow routes). The body limit also bounds one-append
+// budget overshoot. The read route is session-authed and workspace-scoped via the row.
+export const logsRoutes = [
+    {
+        prefix: '/runs/jobs/current',
+        auth: AUTH_LEASED_JOB,
+        plugins: [
+            createRawBodyPlugin({
+                contentType: 'application/x-ndjson',
+                bodyLimit: config.LOG_APPEND_BODY_LIMIT_BYTES
+            })
+        ],
+        routes: [
+            appendLogsRoute
+        ]
+    },
+    {
+        prefix: '/steps',
+        auth: AUTH_USER,
+        routes: [
+            readLogsRoute
+        ]
+    }
+];
+
+//# sourceMappingURL=index.js.map

package/dist/presentation/routes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/index.ts"],"sourcesContent":["import {AUTH_LEASED_JOB, AUTH_USER} from '@shipfox/api-auth-context';\nimport {createRawBodyPlugin, type RouteGroup} from '@shipfox/node-fastify';\nimport {config} from '#config.js';\nimport {appendLogsRoute} from './append-logs.js';\nimport {readLogsRoute} from './read-logs.js';\n\n// Keep the lease-authed append in its own Fastify scope so the raw NDJSON parser does not\n// disturb the JSON read route (or workflow routes). The body limit also bounds one-append\n// budget overshoot. The read route is session-authed and workspace-scoped via the row.\nexport const logsRoutes: RouteGroup[] = [\n  {\n    prefix: '/runs/jobs/current',\n    auth: AUTH_LEASED_JOB,\n    plugins: [\n      createRawBodyPlugin({\n        contentType: 'application/x-ndjson',\n        bodyLimit: config.LOG_APPEND_BODY_LIMIT_BYTES,\n      }),\n    ],\n    routes: [appendLogsRoute],\n  },\n  {\n    prefix: '/steps',\n    auth: AUTH_USER,\n    routes: [readLogsRoute],\n  },\n];\n"],"names":["AUTH_LEASED_JOB","AUTH_USER","createRawBodyPlugin","config","appendLogsRoute","readLogsRoute","logsRoutes","prefix","auth","plugins","contentType","bodyLimit","LOG_APPEND_BODY_LIMIT_BYTES","routes"],"mappings":"AAAA,SAAQA,eAAe,EAAEC,SAAS,QAAO,4BAA4B;AACrE,SAAQC,mBAAmB,QAAwB,wBAAwB;AAC3E,SAAQC,MAAM,QAAO,aAAa;AAClC,SAAQC,eAAe,QAAO,mBAAmB;AACjD,SAAQC,aAAa,QAAO,iBAAiB;AAE7C,0FAA0F;AAC1F,0FAA0F;AAC1F,uFAAuF;AACvF,OAAO,MAAMC,aAA2B;IACtC;QACEC,QAAQ;QACRC,MAAMR;QACNS,SAAS;YACPP,oBAAoB;gBAClBQ,aAAa;gBACbC,WAAWR,OAAOS,2BAA2B;YAC/C;SACD;QACDC,QAAQ;YAACT;SAAgB;IAC3B;IACA;QACEG,QAAQ;QACRC,MAAMP;QACNY,QAAQ;YAACR;SAAc;IACzB;CACD,CAAC"}