one-shared 0.0.0-stage → 1.1.0

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "one-shared",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "description": "",
+  "homepage": "https://github.com/eightseventeen/one-shared#readme",
+  "bugs": {
+    "url": "https://github.com/eightseventeen/one-shared/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eightseventeen/one-shared.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsdown",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "@neondatabase/serverless": "^1.2.0",
+    "drizzle-orm": "^1.0.0-rc.4",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "^1.0.0-rc.4",
+    "@neondatabase/serverless": "^1.2.0",
+    "zod": "^4.6.5"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts"
+}

package/schema.ts

@@ -0,0 +1,211 @@
+import { defineRelations, type Json } from "drizzle-orm";
+import {
+  pgEnum,
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  jsonb,
+  index,
+  integer,
+  boolean,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const statusSignalEnum = pgEnum("status_signal", [
+  "recovery",
+  "failure",
+]);
+
+export const teamsTable = pgTable("teams", {
+  id: uuid().primaryKey().defaultRandom(),
+  slackTeamId: text().notNull(),
+  installerId: text().notNull(),
+  installerToken: text(),
+  scopes: text().array(),
+  teamName: text(),
+  botToken: text().notNull(),
+  botScopes: text().array().notNull(),
+  botUserId: text().notNull(),
+  botId: text().notNull(),
+});
+
+export const eventsTable = pgTable(
+  "events",
+  {
+    id: uuid().primaryKey().defaultRandom(),
+    channelId: uuid()
+      .notNull()
+      .references(() => channelsTable.id),
+    slackAuthorId: text().notNull(),
+    slackChannelId: text().notNull(),
+    slackTeamId: text().notNull(),
+    ts: timestamp().notNull().defaultNow(),
+    textRaw: text(),
+    textNorm: text(),
+    payload: jsonb("payload").$type<Json>().notNull(),
+    mlClassification: integer().notNull(),
+    permalink: text().notNull(),
+  },
+  (t) => [
+    index("events_stream_ts_idx").on(t.channelId, t.ts),
+    index("events_stream_ts_event_idx").on(
+      t.channelId,
+      t.ts,
+      t.id,
+    ),
+    index("events_stream_idx").on(t.channelId),
+  ],
+);
+
+export const channelsTable = pgTable("channels", {
+  id: uuid().primaryKey().defaultRandom(),
+  slackChannelId: text().notNull(),
+  slackName: text().notNull(),
+});
+
+export const prewatchResultsTable = pgTable("prewatchResults", {
+  id: uuid().primaryKey().defaultRandom(),
+  triggerEventId: uuid()
+    .notNull()
+    .references(() => eventsTable.id),
+  channelId: uuid()
+    .notNull()
+    .references(() => channelsTable.id),
+  suspicious: boolean().notNull(),
+  reasoning: text().notNull(),
+  title: text(),
+  incidentId: uuid().references(() => incidentsTable.id),
+});
+
+export const prewatchPromptEventsTable = pgTable("prewatchPromptEvents", {
+  id: uuid().primaryKey().defaultRandom(),
+  prewatchResultId: uuid()
+    .notNull()
+    .references(() => prewatchResultsTable.id),
+  eventId: uuid()
+    .notNull()
+    .references(() => eventsTable.id),
+});
+
+export const prewatchEvidenceEventsTable = pgTable("prewatchEvidenceIds", {
+  id: uuid().primaryKey().defaultRandom(),
+  prewatchResultId: uuid()
+    .notNull()
+    .references(() => prewatchResultsTable.id),
+  eventId: uuid()
+    .notNull()
+    .references(() => eventsTable.id),
+});
+
+export const watchResultsTable = pgTable("watchResults", {
+  id: uuid().primaryKey().defaultRandom(),
+  incidentId: uuid()
+    .notNull()
+    .references(() => incidentsTable.id),
+  triggerEventId: uuid()
+    .notNull()
+    .references(() => eventsTable.id),
+  channelId: uuid()
+    .notNull()
+    .references(() => channelsTable.id),
+  statusSignal: statusSignalEnum(),
+  important: boolean().notNull(),
+  description: text(),
+  summary: text(),
+});
+
+export const incidentsTable = pgTable("incidents", {
+  id: uuid().primaryKey().defaultRandom(),
+  channelId: uuid()
+    .notNull()
+    .references(() => channelsTable.id),
+  ts: timestamp().notNull().defaultNow(),
+});
+
+export const incidentCommentsTable = pgTable("incidentComments", {
+  id: uuid().primaryKey().defaultRandom(),
+  incidentId: uuid().notNull().references(() => incidentsTable.id),
+  content: varchar({ length: 10000 }).notNull(),
+  ts: timestamp().notNull().defaultNow()
+})
+
+export const incidentEventsTable = pgTable("incidentEvents", {
+  id: uuid().primaryKey().defaultRandom(),
+  eventId: uuid()
+    .notNull()
+    .references(() => eventsTable.id),
+  incidentId: uuid()
+    .notNull()
+    .references(() => incidentsTable.id),
+});
+
+export const tables = {
+  teams: teamsTable,
+  events: eventsTable,
+  channels: channelsTable,
+  prewatchResults: prewatchResultsTable,
+  prewatchPromptEvents: prewatchPromptEventsTable,
+  prewatchEvidenceEvents: prewatchEvidenceEventsTable,
+  watchResults: watchResultsTable,
+  incidents: incidentsTable,
+  incidentEvents: incidentEventsTable,
+  incidentComments: incidentCommentsTable
+};
+
+/*
+const comment = db.query.incidentComments.findFirst({
+  with: {
+    incident: true
+  }
+})
+
+console.log('The comment was made on this incident:', comment.incident) // GOOD
+console.log('The comment was made on this incident:', comment.incidents) // BAD
+*/
+
+export const relations = defineRelations(tables, (props) => {
+  return {
+    incidents: {
+      incidentEvents: props.many.incidentEvents(),
+      incidentComments: props.many.incidentComments(),
+      channel: props.one.channels({
+        from: props.incidents.channelId,
+        to: props.channels.id,
+        optional: false,
+      }),
+    },
+    incidentComments: {
+      incident: props.one.incidents({
+        from: props.incidentComments.incidentId,
+        to: props.incidents.id,
+        optional: false
+      })
+    },
+    incidentEvents: {
+      incident: props.one.incidents({
+        from: props.incidentEvents.incidentId,
+        to: props.incidents.id,
+        optional: false,
+      }),
+      event: props.one.events({
+        from: props.incidentEvents.eventId,
+        to: props.events.id,
+        optional: false,
+      }),
+    },
+    events: {
+      prewatchResult: props.one.prewatchResults({
+        from: props.events.id,
+        to: props.prewatchResults.triggerEventId,
+        optional: true,
+      }),
+      watchResult: props.one.watchResults({
+        from: props.events.id,
+        to: props.watchResults.triggerEventId,
+        optional: true,
+      }),
+    },
+  };
+});
+

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/tsdown.config.mts

@@ -0,0 +1,17 @@
+/// 
+
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: ['index.ts'],
+  format: ['cjs', 'esm'], // Build for commonJS and ESmodules
+  dts: true, // Generate declaration file (.d.ts)
+  target: 'node16',
+  sourcemap: true,
+  clean: true,
+  deps: { neverBundle: true },
+  outExtensions: ({ format }) => ({
+    js: format === 'cjs' ? '.js' : '.mjs',
+    dts: format === 'cjs' ? '.d.ts' : '.d.mts',
+  }),
+})

package/types.ts

@@ -0,0 +1,229 @@
+import db from "./db";
+import { z } from "zod";
+import {
+  channelsTable,
+  eventsTable,
+  prewatchEvidenceEventsTable,
+  prewatchPromptEventsTable,
+  prewatchResultsTable,
+  teamsTable,
+  incidentEventsTable,
+  incidentsTable,
+  watchResultsTable,
+  statusSignalEnum,
+  incidentCommentsTable,
+} from "./schema";
+
+export type Db = typeof db;
+
+import { createSchemaFactory } from "drizzle-orm/zod";
+
+const { createSelectSchema, createInsertSchema } = createSchemaFactory({
+  coerce: {
+    date: true,
+  },
+});
+
+// Enums
+export const statusSignalSchema = createSelectSchema(statusSignalEnum);
+export type StatusSignal = z.infer<typeof statusSignalSchema>;
+
+// Tables
+export const eventSchema = createSelectSchema(eventsTable);
+export type Event = z.infer<typeof eventSchema>;
+
+export const eventInsertSchema = createInsertSchema(eventsTable);
+export type EventInsert = z.infer<typeof eventInsertSchema>;
+
+export const channelSchema = createSelectSchema(channelsTable);
+export type Channel = z.infer<typeof channelSchema>;
+
+export const teamSchema = createSelectSchema(teamsTable);
+export type Team = z.infer<typeof teamSchema>;
+
+export const teamInsertSchema = createInsertSchema(teamsTable);
+export type TeamInsert = z.infer<typeof teamInsertSchema>;
+
+export const prewatchResultSchema = createSelectSchema(prewatchResultsTable);
+export type PrewatchResult = z.infer<typeof prewatchResultSchema>;
+export const prewatchResultInsertSchema =
+  createInsertSchema(prewatchResultsTable);
+export type PrewatchResultInsert = z.infer<typeof prewatchResultInsertSchema>;
+
+export const prewatchPromptEventSchema = createSelectSchema(
+  prewatchPromptEventsTable,
+);
+export type PrewatchPromptEvent = z.infer<typeof prewatchPromptEventSchema>;
+export const prewatchPromptEventInsertSchema = createInsertSchema(
+  prewatchPromptEventsTable,
+);
+export type PrewatchPromptEventInsert = z.infer<
+  typeof prewatchPromptEventInsertSchema
+>;
+
+export const watchResultSchema = createSelectSchema(watchResultsTable);
+export type WatchResult = z.infer<typeof watchResultSchema>;
+export const watchResultInsertSchema = createInsertSchema(watchResultsTable);
+export type WatchResultInsert = z.infer<typeof watchResultInsertSchema>;
+
+export const incidentSchema = createSelectSchema(incidentsTable);
+export type Incident = z.infer<typeof incidentSchema>;
+export const incidentInsertSchema = createInsertSchema(incidentsTable);
+export type IncidentInsert = z.infer<typeof incidentInsertSchema>;
+
+export const incidentCommentsSchema = createSelectSchema(incidentCommentsTable);
+export type IncidentComments = z.infer<typeof incidentCommentsSchema>;
+export const incidentCommentsInsertSchema = createInsertSchema(
+  incidentCommentsTable,
+);
+export type IncidentCommentsInsert = z.infer<
+  typeof incidentCommentsInsertSchema
+>;
+
+export const incidentEventSchema = createSelectSchema(incidentEventsTable);
+export type IncidentEvent = z.infer<typeof incidentEventSchema>;
+export const incidentEventInsertSchema =
+  createInsertSchema(incidentEventsTable);
+export type IncidentEventInsert = z.infer<typeof incidentEventInsertSchema>;
+
+export const prewatchEvidenceEventSchema = createSelectSchema(
+  prewatchEvidenceEventsTable,
+);
+export type PrewatchEvidenceEvent = z.infer<typeof prewatchEvidenceEventSchema>;
+export const prewatchEvidenceEventInsertSchema = createInsertSchema(
+  prewatchEvidenceEventsTable,
+);
+export type PrewatchEvidenceEventInsert = z.infer<
+  typeof prewatchEvidenceEventInsertSchema
+>;
+
+const relatedEventSchema = eventSchema.extend({
+  prewatchResult: prewatchResultSchema.nullish(),
+  watchResult: watchResultSchema.nullish(),
+});
+
+const relatedIncidentEventSchema = incidentEventSchema.extend({
+  event: relatedEventSchema,
+});
+
+export interface PromptEvent {
+  id: string;
+  ts: string;
+  slackAuthorId: string;
+  textRaw: string | null;
+  textNorm: string | null;
+}
+
+export const unsuspiciousPrewatchGenerationSchema = z.object({
+  suspicious: z.literal(false),
+  reasoning: z.string(),
+});
+
+export const suspiciousPrewatchGenerationSchema = z.object({
+  suspicious: z.literal(true),
+  reasoning: z.string(),
+  title: z.string(),
+  evidenceEventIds: z.string().array(),
+});
+export type SuspiciousPrewatchGeneration = z.infer<
+  typeof suspiciousPrewatchGenerationSchema
+>;
+
+export const importantGenerationSchema = z
+  .object({
+    important: z.literal(true),
+    statusSignal: statusSignalSchema,
+    description: z.string(),
+    summary: z.string(),
+  })
+  .strict();
+
+export const unimportantGenerationSchema = z
+  .object({
+    important: z.literal(false),
+  })
+  .strict();
+
+export const watchGenerationSchema = z.union([
+  importantGenerationSchema,
+  unimportantGenerationSchema,
+]);
+export type WatchGeneration = z.infer<typeof watchGenerationSchema>;
+
+export const prewatchGenerationSchema = z.union([
+  suspiciousPrewatchGenerationSchema,
+  unsuspiciousPrewatchGenerationSchema,
+]);
+export type PrewatchGeneration = z.infer<typeof prewatchGenerationSchema>;
+
+// API
+
+export const emptyParamsSchema = z.tuple([]).readonly();
+export type EmptyParams = z.infer<typeof emptyParamsSchema>;
+
+export const singleParamSchema = z.tuple([z.string()]).readonly();
+export type SingleParam = z.infer<typeof singleParamSchema>;
+
+export type OptionalParams<S, K extends PropertyKey> = S extends {
+  [P in K]: infer T extends z.ZodType;
+}
+  ? { [P in K]: z.infer<T> }
+  : { [P in K]?: never };
+
+export const incidentWithChannelSchema = incidentSchema.extend({
+  channel: channelSchema,
+});
+
+// GET /health
+export const getHealthOutputSchema = z.object({
+  startupTime: z.string(),
+  memoryLoad: z.number(),
+});
+
+// GET /incidents
+export const getIncidentsOutputSchema = incidentWithChannelSchema.array();
+
+// GET /incidents/:incidentId
+export const getIncidentOutputSchema = incidentSchema.extend({
+  incidentEvents: relatedIncidentEventSchema.array(),
+  channel: channelSchema,
+});
+
+export const postIncidentCommentInputSchema = incidentCommentsInsertSchema.pick(
+  {
+    incidentId: true,
+    content: true,
+  },
+);
+
+export const postIncidentCommentOutputSchema = incidentCommentsSchema;
+
+export const apiSchemas = {
+  getHealth: {
+    method: "GET",
+    path: "health",
+    output: getHealthOutputSchema,
+  },
+  getIncidents: {
+    method: "GET",
+    path: "incidents",
+    output: getIncidentsOutputSchema,
+  },
+  getIncident: {
+    method: "GET",
+    path: "incidents",
+    output: getIncidentOutputSchema,
+    params: singleParamSchema,
+  },
+  postIncidentComment: {
+    method: "POST",
+    path: "incidents",
+    output: postIncidentCommentOutputSchema,
+    input: postIncidentCommentInputSchema,
+  },
+};
+
+export type ApiSchemas = typeof apiSchemas;
+
+export type ProcedureName = keyof ApiSchemas;
+// 'getHealth' | 'getIncidents' | 'getIncident' ...

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.