@pepys/source-github 0.0.0-stage → 0.1.0

package/src/consumers/github-release.ts

@@ -0,0 +1,125 @@
+import {
+  initGithubReleaseModel,
+  readGithubReleaseRow,
+  toGithubReleaseID,
+  updateGithubReleaseModel,
+} from '../generated/github-release-boundary.ts';
+import type {
+  EntityID,
+  GithubReleaseMessage,
+  GithubReleaseModel,
+  GithubReleaseOperation,
+  GithubReleaseRow,
+} from '../generated/github-release-boundary.ts';
+import { findField } from '../utils/find-field.ts';
+
+export type {
+  GithubReleaseMessage,
+  GithubReleaseModel,
+} from '../generated/github-release-boundary.ts';
+
+// scriptc takes the model and message types through a re-export, but not the two functions
+export function init(): GithubReleaseModel {
+  return initGithubReleaseModel();
+}
+
+export function update(
+  model: GithubReleaseModel,
+  message: GithubReleaseMessage,
+): GithubReleaseModel {
+  return updateGithubReleaseModel(model, message);
+}
+
+export function applyFact(factJSON: string): string {
+  return JSON.stringify(mapFact(factJSON));
+}
+
+// GitHub never uses a release ID again, so a tombstone is never cleared. On a tie of times the
+// later fact in the stream wins: the host gives each fact ID once, so every replay keeps that order.
+function mapFact(factJSON: string): GithubReleaseOperation[] {
+  const fact: unknown = JSON.parse(factJSON);
+  const type = findField(fact, 'type');
+  const at = findField(fact, 'at');
+  const releaseID = findField(fact, 'payload', 'release', 'id');
+
+  if (typeof at !== 'string' || typeof releaseID !== 'number') {
+    return [];
+  }
+
+  const id = toGithubReleaseID(`${releaseID}`);
+  const stored = readGithubReleaseRow(id);
+  const isDelete = type === 'github.release.deleted';
+  const deletedAt = stored?.deleted_at ?? (isDelete ? at : null);
+  const given = buildReleaseRow(id, findField(fact, 'payload'), at);
+  const wins = given !== undefined && (stored === undefined || at >= stored.updated_at);
+  const row = wins ? given : stored;
+
+  if (row === undefined) {
+    return [];
+  }
+
+  const next: GithubReleaseRow = { ...row, deleted_at: deletedAt };
+
+  if (stored !== undefined && JSON.stringify(stored) === JSON.stringify(next)) {
+    return [];
+  }
+
+  return [{ upsert: { github_release: next } }];
+}
+
+// A fact that holds the release ID alone gives no row of its own.
+function buildReleaseRow(
+  id: GithubReleaseRow['id'],
+  payload: unknown,
+  at: string,
+): GithubReleaseRow | undefined {
+  const release = findField(payload, 'release');
+  const repositoryID = findField(payload, 'repository', 'id');
+  const fullName = findField(payload, 'repository', 'full_name');
+  const tagName = findField(release, 'tag_name');
+  const target = findField(release, 'target_commitish');
+  const name = findField(release, 'name');
+  const url = findField(release, 'html_url');
+  const createdAt = findField(release, 'created_at');
+  const publishedAt = findField(release, 'published_at');
+
+  if (typeof repositoryID !== 'number' || typeof fullName !== 'string') {
+    return undefined;
+  }
+
+  if (typeof tagName !== 'string' || typeof target !== 'string' || typeof url !== 'string') {
+    return undefined;
+  }
+
+  if (typeof createdAt !== 'string') {
+    return undefined;
+  }
+
+  return {
+    id,
+    repository_id: toEntityID(`github:repo:${repositoryID}`),
+    repository_full_name: fullName,
+    tag_name: tagName,
+    target_commitish: target,
+    name: typeof name === 'string' && name !== '' ? name : tagName,
+    url,
+    is_draft: findField(release, 'draft') === true,
+    is_prerelease: findField(release, 'prerelease') === true,
+    created_at: createdAt,
+    published_at: typeof publishedAt === 'string' ? publishedAt : null,
+    updated_at: at,
+    deleted_at: null,
+  };
+}
+
+function isEntityID(text: string): text is EntityID {
+  return text.length > 0;
+}
+
+function toEntityID(text: string): EntityID {
+  if (!isEntityID(text)) {
+    throw new Error('an entity ID is never empty');
+  }
+
+  return text;
+}

package/src/families/build-family-types.ts

@@ -0,0 +1,16 @@
+import type { z } from 'zod';
+
+// One fact type per action, `github.<family>.<action>`, each with the family's payload schema.
+export function buildFamilyTypes(
+  family: string,
+  actions: readonly string[],
+  schema: z.ZodType,
+): Readonly<Record<string, z.ZodType>> {
+  const types: Record<string, z.ZodType> = {};
+
+  for (const action of actions) {
+    types[`github.${family}.${action}`] = schema;
+  }
+
+  return types;
+}

package/src/families/deployment-family.ts

@@ -0,0 +1,15 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+
+const payloadSchema = z.looseObject({ deployment: z.looseObject({ id: z.number().int() }) });
+
+// A deployment and each of its statuses, as facts of the one deployment entity.
+export const deploymentFamily = defineFactFamily({
+  stream: 'facts.github.deployment',
+  api: 'github/2022-11-28',
+  entityKind: 'github:deployment',
+  types: {
+    'github.deployment.created': payloadSchema,
+    'github.deployment.status_created': payloadSchema,
+  },
+});

package/src/families/issue-family.ts

@@ -0,0 +1,38 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `issues` webhook event.
+const actions = [
+  'assigned',
+  'closed',
+  'deleted',
+  'demilestoned',
+  'edited',
+  'labeled',
+  'locked',
+  'milestoned',
+  'opened',
+  'pinned',
+  'reopened',
+  'transferred',
+  'typed',
+  'unassigned',
+  'unlabeled',
+  'unlocked',
+  'unpinned',
+  'untyped',
+] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  issue: z.looseObject({ id: z.number().int() }),
+});
+
+// Stored with no consumer.
+export const issueFamily = defineFactFamily({
+  stream: 'facts.github.issue',
+  api: 'github/2022-11-28',
+  entityKind: 'github:issue',
+  types: buildFamilyTypes('issue', actions, payloadSchema),
+});

package/src/families/pull-request-family.ts

@@ -0,0 +1,42 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `pull_request` webhook event, and `resynced` for a pull request
+// that the resync pull read from the API.
+const actions = [
+  'assigned',
+  'auto_merge_disabled',
+  'auto_merge_enabled',
+  'closed',
+  'converted_to_draft',
+  'demilestoned',
+  'dequeued',
+  'edited',
+  'enqueued',
+  'labeled',
+  'locked',
+  'milestoned',
+  'opened',
+  'ready_for_review',
+  'reopened',
+  'resynced',
+  'review_request_removed',
+  'review_requested',
+  'synchronize',
+  'unassigned',
+  'unlabeled',
+  'unlocked',
+] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  pull_request: z.looseObject({ id: z.number().int(), updated_at: z.string() }),
+});
+
+export const pullRequestFamily = defineFactFamily({
+  stream: 'facts.github.pull_request',
+  api: 'github/2022-11-28',
+  entityKind: 'github:pull_request',
+  types: buildFamilyTypes('pull_request', actions, payloadSchema),
+});

package/src/families/pull-request-review-family.ts

@@ -0,0 +1,18 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+const actions = ['dismissed', 'edited', 'submitted'] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  review: z.looseObject({ id: z.number().int() }),
+});
+
+// Stored with no consumer.
+export const pullRequestReviewFamily = defineFactFamily({
+  stream: 'facts.github.pull_request_review',
+  api: 'github/2022-11-28',
+  entityKind: 'github:pull_request_review',
+  types: buildFamilyTypes('pull_request_review', actions, payloadSchema),
+});

package/src/families/ref-family.ts

@@ -0,0 +1,14 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+
+const repositorySchema = z.looseObject({ id: z.number().int() });
+
+// A push to the default branch or to a tag. The entity is `github:ref:<repository ID>:<ref>`.
+export const refFamily = defineFactFamily({
+  stream: 'facts.github.ref',
+  api: 'github/2022-11-28',
+  entityKind: 'github:ref',
+  types: {
+    'github.ref.pushed': z.looseObject({ ref: z.string(), repository: repositorySchema }),
+  },
+});

package/src/families/release-family.ts

@@ -0,0 +1,28 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `release` webhook event, and `resynced` for a release that the
+// resync pull read from the API.
+const actions = [
+  'created',
+  'deleted',
+  'edited',
+  'prereleased',
+  'published',
+  'released',
+  'resynced',
+  'unpublished',
+] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  release: z.looseObject({ id: z.number().int() }),
+});
+
+export const releaseFamily = defineFactFamily({
+  stream: 'facts.github.release',
+  api: 'github/2022-11-28',
+  entityKind: 'github:release',
+  types: buildFamilyTypes('release', actions, payloadSchema),
+});

package/src/families/workflow-run-family.ts

@@ -0,0 +1,18 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+const actions = ['completed', 'in_progress', 'requested'] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  workflow_run: z.looseObject({ id: z.number().int() }),
+});
+
+// Stored with no consumer.
+export const workflowRunFamily = defineFactFamily({
+  stream: 'facts.github.workflow_run',
+  api: 'github/2022-11-28',
+  entityKind: 'github:workflow_run',
+  types: buildFamilyTypes('workflow_run', actions, payloadSchema),
+});

package/src/generated/github-deploy-boundary.ts

@@ -0,0 +1,308 @@
+// Generated by `pepys build`. Do not edit.
+
+declare const idTag: unique symbol;
+declare const kindTag: unique symbol;
+
+export type EntityID = string & { readonly [idTag]: 'EntityID' };
+
+type KindedID<Kind extends string> = EntityID & { readonly [kindTag]: Kind };
+
+export type GithubDeployID = KindedID<'github:deploy'>;
+
+export function toGithubDeployID(id: string): GithubDeployID {
+  const text = 'github:deploy:' + id;
+
+  if (!isGithubDeployID(text)) {
+    throw new Error('an ID of the kind github:deploy is never empty');
+  }
+
+  return text;
+}
+
+export function parseGithubDeployID(text: string): GithubDeployID | undefined {
+  return isGithubDeployID(text) ? text : undefined;
+}
+
+function isGithubDeployID(text: string): text is GithubDeployID {
+  return text.length > 'github:deploy:'.length && text.startsWith('github:deploy:');
+}
+
+export type GithubDeploymentID = KindedID<'github:deployment'>;
+
+export function toGithubDeploymentID(id: string): GithubDeploymentID {
+  const text = 'github:deployment:' + id;
+
+  if (!isGithubDeploymentID(text)) {
+    throw new Error('an ID of the kind github:deployment is never empty');
+  }
+
+  return text;
+}
+
+export function parseGithubDeploymentID(text: string): GithubDeploymentID | undefined {
+  return isGithubDeploymentID(text) ? text : undefined;
+}
+
+function isGithubDeploymentID(text: string): text is GithubDeploymentID {
+  return text.length > 'github:deployment:'.length && text.startsWith('github:deployment:');
+}
+
+export type GithubRefID = KindedID<'github:ref'>;
+
+export function toGithubRefID(id: string): GithubRefID {
+  const text = 'github:ref:' + id;
+
+  if (!isGithubRefID(text)) {
+    throw new Error('an ID of the kind github:ref is never empty');
+  }
+
+  return text;
+}
+
+export function parseGithubRefID(text: string): GithubRefID | undefined {
+  return isGithubRefID(text) ? text : undefined;
+}
+
+function isGithubRefID(text: string): text is GithubRefID {
+  return text.length > 'github:ref:'.length && text.startsWith('github:ref:');
+}
+
+export const settings = {
+  "deployTagPattern": "deployed/<environment>"
+} as const;
+
+export interface GithubDeployModel {
+  input: string;
+}
+
+export type GithubDeployMessage = { kind: 'apply'; input: string } | { kind: 'reset' };
+
+export function initGithubDeployModel(): GithubDeployModel {
+  return { input: '' };
+}
+
+export function updateGithubDeployModel(model: GithubDeployModel, message: GithubDeployMessage): GithubDeployModel {
+  return message.kind === 'reset' ? initGithubDeployModel() : { ...model, input: message.input };
+}
+
+export interface GithubRefPushedPayload {
+  ref: string;
+  repository: GithubRefPushedPayloadRepository;
+}
+
+export interface GithubRefPushedPayloadRepository {
+  id: number;
+}
+
+export interface GithubDeploymentPayload {
+  deployment: GithubDeploymentPayloadDeployment;
+}
+
+export interface GithubDeploymentPayloadDeployment {
+  id: number;
+}
+
+export type GithubDeployFact =
+  | { id: string; type: 'github.ref.pushed'; entity: string; at: string; payload: GithubRefPushedPayload }
+  | { id: string; type: 'github.deployment.created' | 'github.deployment.status_created'; entity: string; at: string; payload: GithubDeploymentPayload };
+
+export function parseGithubDeployFact(factJSON: string): GithubDeployFact | undefined {
+  const parsed: unknown = JSON.parse(factJSON);
+
+  return decodeGithubDeployFact(parsed);
+}
+
+function decodeGithubDeployFact(value: unknown): GithubDeployFact | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const id = 'id' in value ? value.id : undefined;
+  const type = 'type' in value ? value.type : undefined;
+  const entity = 'entity' in value ? value.entity : undefined;
+  const at = 'at' in value ? value.at : undefined;
+  const payload = 'payload' in value ? value.payload : undefined;
+
+  if (typeof id !== 'string' || typeof entity !== 'string' || typeof at !== 'string') {
+    return undefined;
+  }
+
+  if (type === 'github.ref.pushed') {
+    const decoded = decodeGithubRefPushedPayload(payload);
+
+    if (decoded === undefined) {
+      return undefined;
+    }
+
+    return { id, type, entity, at, payload: decoded };
+  }
+
+  if (type === 'github.deployment.created' || type === 'github.deployment.status_created') {
+    const decoded = decodeGithubDeploymentPayload(payload);
+
+    if (decoded === undefined) {
+      return undefined;
+    }
+
+    return { id, type, entity, at, payload: decoded };
+  }
+
+  return undefined;
+}
+
+function decodeGithubRefPushedPayload(value: unknown): GithubRefPushedPayload | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const raw0 = 'ref' in value ? value.ref : undefined;
+  const field0 = typeof raw0 === 'string' ? raw0 : undefined;
+
+  if (field0 === undefined) {
+    return undefined;
+  }
+
+  const raw1 = 'repository' in value ? value.repository : undefined;
+  const field1 = decodeGithubRefPushedPayloadRepository(raw1);
+
+  if (field1 === undefined) {
+    return undefined;
+  }
+
+  return {
+    ref: field0,
+    repository: field1,
+  };
+}
+
+function decodeGithubRefPushedPayloadRepository(value: unknown): GithubRefPushedPayloadRepository | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const raw0 = 'id' in value ? value.id : undefined;
+  const field0 = typeof raw0 === 'number' ? raw0 : undefined;
+
+  if (field0 === undefined) {
+    return undefined;
+  }
+
+  return {
+    id: field0,
+  };
+}
+
+function decodeGithubDeploymentPayload(value: unknown): GithubDeploymentPayload | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const raw0 = 'deployment' in value ? value.deployment : undefined;
+  const field0 = decodeGithubDeploymentPayloadDeployment(raw0);
+
+  if (field0 === undefined) {
+    return undefined;
+  }
+
+  return {
+    deployment: field0,
+  };
+}
+
+function decodeGithubDeploymentPayloadDeployment(value: unknown): GithubDeploymentPayloadDeployment | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const raw0 = 'id' in value ? value.id : undefined;
+  const field0 = typeof raw0 === 'number' ? raw0 : undefined;
+
+  if (field0 === undefined) {
+    return undefined;
+  }
+
+  return {
+    id: field0,
+  };
+}
+
+export interface GithubDeployRow {
+  id: GithubDeployID;
+  repository_id: EntityID;
+  environment: string;
+  target: string | null;
+  sha: string;
+  signal: string;
+  deployed_at: string;
+}
+
+export interface GithubDeployKey {
+  id: GithubDeployID;
+}
+
+export type GithubDeployOperation =
+  | { upsert: { github_deploy: GithubDeployRow } }
+  | { delete: { github_deploy: GithubDeployKey } };
+
+declare function readGithubDeployLength(key: string): number;
+declare function readGithubDeployInto(key: string, row: Uint8Array): void;
+
+export function readGithubDeployRow(key: string): GithubDeployRow | undefined {
+  const length = readGithubDeployLength(key);
+
+  if (length < 0) {
+    return undefined;
+  }
+
+  const row = new Uint8Array(length);
+
+  readGithubDeployInto(key, row);
+
+  const parsed: unknown = JSON.parse(new TextDecoder().decode(row));
+
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    return undefined;
+  }
+
+  if (!('id' in parsed) || (typeof parsed.id !== 'string' || !isGithubDeployID(parsed.id))) {
+    return undefined;
+  }
+
+  if (!('repository_id' in parsed) || (!isEntityID(parsed.repository_id))) {
+    return undefined;
+  }
+
+  if (!('environment' in parsed) || (typeof parsed.environment !== 'string')) {
+    return undefined;
+  }
+
+  if (!('target' in parsed) || (parsed.target !== null && (typeof parsed.target !== 'string'))) {
+    return undefined;
+  }
+
+  if (!('sha' in parsed) || (typeof parsed.sha !== 'string')) {
+    return undefined;
+  }
+
+  if (!('signal' in parsed) || (typeof parsed.signal !== 'string')) {
+    return undefined;
+  }
+
+  if (!('deployed_at' in parsed) || (typeof parsed.deployed_at !== 'string')) {
+    return undefined;
+  }
+
+  return {
+    id: parsed.id,
+    repository_id: parsed.repository_id,
+    environment: parsed.environment,
+    target: parsed.target,
+    sha: parsed.sha,
+    signal: parsed.signal,
+    deployed_at: parsed.deployed_at,
+  };
+}
+
+function isEntityID(value: unknown): value is EntityID {
+  return typeof value === 'string';
+}

package/src/generated/github-deploy.sql

@@ -0,0 +1,24 @@
+-- Generated by `pepys build`. Do not edit.
+
+CREATE TABLE "github_deploy" (
+  "id" TEXT NOT NULL,
+  "repository_id" TEXT NOT NULL,
+  "environment" TEXT NOT NULL,
+  "target" TEXT,
+  "sha" TEXT NOT NULL,
+  "signal" TEXT NOT NULL,
+  "deployed_at" TEXT NOT NULL,
+  PRIMARY KEY ("id")
+);
+
+CREATE INDEX "github_deploy_repository_id_environment_idx" ON "github_deploy" ("repository_id", "environment");
+
+CREATE VIEW "entity" AS
+SELECT
+  "id" AS "id",
+  'github:deploy' AS "kind",
+  "sha" AS "title",
+  NULL AS "url",
+  NULL AS "actor",
+  "deployed_at" AS "updated_at"
+FROM "github_deploy";