Add guide alarms endpoint

package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "license": "MIT",
   "type": "module",
-  "packageManager": "pnpm@9.4.0",
+  "packageManager": "pnpm@9.5.0",
   "scripts": {
     "test": "mocha --node-option enable-source-maps --forbid-only --forbid-pending dist/**/*.spec.js",
     "generate": "prisma generate",
@@ -15,7 +15,7 @@
     "populate": "prisma migrate deploy && prisma db seed",
     "dev": "node --watch --enable-source-maps ./dist/index.js",
     "codegen": "graphql-codegen --config tasks/codegen.ts",
-    "codegen:watch": "pnpm codegen --watch 'src/graphql/types/*.ts'",
+    "codegen:watch": "pnpm codegen --watch 'src/graphql/*.ts'",
     "lint": "pnpm lint:prettier && pnpm lint:eslint",
     "lint:prettier": "prettier --check .",
     "lint:eslint": "eslint .",

prisma/migrations/20240711084258_add_guide_alarm/migration.sql

@@ -0,0 +1,8 @@
+-- CreateTable
+CREATE TABLE "GuideAlarm" (
+    "wfs" "WfsType" NOT NULL,
+    "limit" INTEGER NOT NULL,
+    "enabled" BOOLEAN NOT NULL DEFAULT true,
+
+    CONSTRAINT "GuideAlarm_pkey" PRIMARY KEY ("wfs")
+);

prisma/schema.prisma

@@ -218,6 +218,12 @@ model GemsGuideLoop {
   flexure   Boolean
 }
 
+model GuideAlarm {
+  wfs     WfsType @id
+  limit   Int
+  enabled Boolean @default(true)
+}
+
 // model pwfs1 {
 //   pk Int @id @default(autoincrement())
 //   filter String

src/graphql/gen/index.ts

@@ -110,6 +110,19 @@ export type GemsInstrument = {
   pk: Scalars['Int']['output'];
 };
 
+export type GuideAlarm = {
+  __typename?: 'GuideAlarm';
+  enabled: Scalars['Boolean']['output'];
+  limit: Scalars['Int']['output'];
+};
+
+export type GuideAlarms = {
+  __typename?: 'GuideAlarms';
+  OIWFS: GuideAlarm;
+  PWFS1: GuideAlarm;
+  PWFS2: GuideAlarm;
+};
+
 export type GuideLoop = {
   __typename?: 'GuideLoop';
   daytimeMode: Scalars['Boolean']['output'];
@@ -198,6 +211,7 @@ export type Mutation = {
   updateConfiguration: Configuration;
   updateGemsGuideLoop: GemsGuideLoop;
   updateGemsInstrument: GemsInstrument;
+  updateGuideAlarm: GuideAlarm;
   updateGuideLoop: GuideLoop;
   updateMechanism: Mechanism;
   updateRotator: Rotator;
@@ -327,6 +341,13 @@ export type MutationUpdateGemsInstrumentArgs = {
 };
 
 
+export type MutationUpdateGuideAlarmArgs = {
+  enabled?: InputMaybe<Scalars['Boolean']['input']>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  wfs: WfsType;
+};
+
+
 export type MutationUpdateGuideLoopArgs = {
   daytimeMode?: InputMaybe<Scalars['Boolean']['input']>;
   lightPath?: InputMaybe<Scalars['String']['input']>;
@@ -432,6 +453,7 @@ export type Query = {
   distinctPorts: Array<DistinctPort>;
   gemsGuideLoop?: Maybe<GemsGuideLoop>;
   gemsInstrument?: Maybe<GemsInstrument>;
+  guideAlarms: GuideAlarms;
   guideLoop?: Maybe<GuideLoop>;
   instrument?: Maybe<Instrument>;
   instruments: Array<Instrument>;
@@ -662,6 +684,8 @@ export type ResolversTypes = {
   Float: ResolverTypeWrapper<Scalars['Float']['output']>;
   GemsGuideLoop: ResolverTypeWrapper<GemsGuideLoop>;
   GemsInstrument: ResolverTypeWrapper<GemsInstrument>;
+  GuideAlarm: ResolverTypeWrapper<GuideAlarm>;
+  GuideAlarms: ResolverTypeWrapper<GuideAlarms>;
   GuideLoop: ResolverTypeWrapper<GuideLoop>;
   GuidingType: GuidingType;
   Instrument: ResolverTypeWrapper<Instrument>;
@@ -699,6 +723,8 @@ export type ResolversParentTypes = {
   Float: Scalars['Float']['output'];
   GemsGuideLoop: GemsGuideLoop;
   GemsInstrument: GemsInstrument;
+  GuideAlarm: GuideAlarm;
+  GuideAlarms: GuideAlarms;
   GuideLoop: GuideLoop;
   Instrument: Instrument;
   Int: Scalars['Int']['output'];
@@ -811,6 +837,19 @@ export type GemsInstrumentResolvers<ContextType = any, ParentType extends Resolv
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
+export type GuideAlarmResolvers<ContextType = any, ParentType extends ResolversParentTypes['GuideAlarm'] = ResolversParentTypes['GuideAlarm']> = {
+  enabled?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+  limit?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type GuideAlarmsResolvers<ContextType = any, ParentType extends ResolversParentTypes['GuideAlarms'] = ResolversParentTypes['GuideAlarms']> = {
+  OIWFS?: Resolver<ResolversTypes['GuideAlarm'], ParentType, ContextType>;
+  PWFS1?: Resolver<ResolversTypes['GuideAlarm'], ParentType, ContextType>;
+  PWFS2?: Resolver<ResolversTypes['GuideAlarm'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
 export type GuideLoopResolvers<ContextType = any, ParentType extends ResolversParentTypes['GuideLoop'] = ResolversParentTypes['GuideLoop']> = {
   daytimeMode?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
   lightPath?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
@@ -899,6 +938,7 @@ export type MutationResolvers<ContextType = any, ParentType extends ResolversPar
   updateConfiguration?: Resolver<ResolversTypes['Configuration'], ParentType, ContextType, RequireFields<MutationUpdateConfigurationArgs, 'pk'>>;
   updateGemsGuideLoop?: Resolver<ResolversTypes['GemsGuideLoop'], ParentType, ContextType, RequireFields<MutationUpdateGemsGuideLoopArgs, 'pk'>>;
   updateGemsInstrument?: Resolver<ResolversTypes['GemsInstrument'], ParentType, ContextType, RequireFields<MutationUpdateGemsInstrumentArgs, 'pk'>>;
+  updateGuideAlarm?: Resolver<ResolversTypes['GuideAlarm'], ParentType, ContextType, RequireFields<MutationUpdateGuideAlarmArgs, 'wfs'>>;
   updateGuideLoop?: Resolver<ResolversTypes['GuideLoop'], ParentType, ContextType, RequireFields<MutationUpdateGuideLoopArgs, 'pk'>>;
   updateMechanism?: Resolver<ResolversTypes['Mechanism'], ParentType, ContextType, RequireFields<MutationUpdateMechanismArgs, 'pk'>>;
   updateRotator?: Resolver<ResolversTypes['Rotator'], ParentType, ContextType, RequireFields<MutationUpdateRotatorArgs, 'pk'>>;
@@ -914,6 +954,7 @@ export type QueryResolvers<ContextType = any, ParentType extends ResolversParent
   distinctPorts?: Resolver<Array<ResolversTypes['DistinctPort']>, ParentType, ContextType, Partial<QueryDistinctPortsArgs>>;
   gemsGuideLoop?: Resolver<Maybe<ResolversTypes['GemsGuideLoop']>, ParentType, ContextType>;
   gemsInstrument?: Resolver<Maybe<ResolversTypes['GemsInstrument']>, ParentType, ContextType>;
+  guideAlarms?: Resolver<ResolversTypes['GuideAlarms'], ParentType, ContextType>;
   guideLoop?: Resolver<Maybe<ResolversTypes['GuideLoop']>, ParentType, ContextType>;
   instrument?: Resolver<Maybe<ResolversTypes['Instrument']>, ParentType, ContextType, Partial<QueryInstrumentArgs>>;
   instruments?: Resolver<Array<ResolversTypes['Instrument']>, ParentType, ContextType, Partial<QueryInstrumentsArgs>>;
@@ -992,6 +1033,8 @@ export type Resolvers<ContextType = any> = {
   El?: ElResolvers<ContextType>;
   GemsGuideLoop?: GemsGuideLoopResolvers<ContextType>;
   GemsInstrument?: GemsInstrumentResolvers<ContextType>;
+  GuideAlarm?: GuideAlarmResolvers<ContextType>;
+  GuideAlarms?: GuideAlarmsResolvers<ContextType>;
   GuideLoop?: GuideLoopResolvers<ContextType>;
   Instrument?: InstrumentResolvers<ContextType>;
   JSON?: GraphQLScalarType;

src/graphql/resolvers/GuideAlarm.ts

@@ -0,0 +1,35 @@
+import { GuideAlarm } from '@prisma/client';
+import { FieldNode } from 'graphql';
+import { prisma } from '../../prisma/db.js';
+import { Resolvers, WfsType } from '../gen/index.js';
+
+export const GuideAlarmResolver: Resolvers = {
+  Query: {
+    async guideAlarms(_parent, _args, _context, info) {
+      // Get the wfs types to query for from the graphql info object
+      const wfsTypesToQuery =
+        ((info.fieldNodes[0]?.selectionSet?.selections as FieldNode[])
+          .map((selection) => selection.name.value)
+          .filter((wfs) => wfs !== '__typename') as WfsType[]) ?? [];
+
+      const alarms = await prisma.guideAlarm.findMany({
+        where: {
+          wfs: {
+            in: wfsTypesToQuery,
+          },
+        },
+      });
+
+      // Convert the array of alarms to an object with the wfs as the key
+      return Object.fromEntries(alarms.map((alarm) => [alarm.wfs, alarm])) as Record<WfsType, GuideAlarm>;
+    },
+  },
+  Mutation: {
+    updateGuideAlarm(_parent, args) {
+      return prisma.guideAlarm.update({
+        where: { wfs: args.wfs },
+        data: args,
+      });
+    },
+  },
+};

src/graphql/types/GuideAlarm.ts

@@ -0,0 +1,24 @@
+export const GuideAlarmTypeDefs = `#graphql
+type GuideAlarm {
+  limit: Int!
+  enabled: Boolean!
+}
+
+type GuideAlarms {
+  OIWFS: GuideAlarm!
+  PWFS1: GuideAlarm!
+  PWFS2: GuideAlarm!
+}
+
+type Query {
+  guideAlarms: GuideAlarms!
+}
+
+type Mutation {
+  updateGuideAlarm(
+    wfs: WfsType!
+    limit: Int
+    enabled: Boolean
+  ): GuideAlarm!
+}
+`;

src/index.ts

@@ -19,6 +19,7 @@ import { UserResolver } from './graphql/resolvers/User.js';
 // TypeDefs
 import { DateTimeResolver, JSONResolver } from 'graphql-scalars';
 import { typeDefs } from './typeDefs.js';
+import { GuideAlarmResolver } from './graphql/resolvers/GuideAlarm.js';
 
 // Resolvers define how to fetch the types defined in your schema.
 const resolvers = {
@@ -37,6 +38,7 @@ const resolvers = {
     ...SlewFlagsResolver.Query,
     ...TargetResolver.Query,
     ...UserResolver.Query,
+    ...GuideAlarmResolver.Query,
   },
   Mutation: {
     ...AltairGuideLoopResolver.Mutation,
@@ -51,6 +53,7 @@ const resolvers = {
     ...SlewFlagsResolver.Mutation,
     ...TargetResolver.Mutation,
     ...UserResolver.Mutation,
+    ...GuideAlarmResolver.Mutation,
   },
 };
 

src/prisma/queries/init/guideAlarm.ts

@@ -0,0 +1,19 @@
+import { Prisma } from '@prisma/client';
+
+export const INITIAL_GUIDE_ALARMS: Prisma.GuideAlarmCreateInput[] = [
+  {
+    wfs: 'PWFS1',
+    limit: 900,
+    enabled: true,
+  },
+  {
+    wfs: 'PWFS2',
+    limit: 900,
+    enabled: true,
+  },
+  {
+    wfs: 'OIWFS',
+    limit: 900,
+    enabled: true,
+  },
+];

src/prisma/queries/write.ts

@@ -6,6 +6,7 @@ import { INITIAL_MECHANISM } from './init/mechanism.js';
 import { INITIAL_ROTATOR } from './init/rotator.js';
 import { INITIAL_SLEW_FLAGS } from './init/slewFlags.js';
 import { INITIAL_USERS } from './init/users.js';
+import { INITIAL_GUIDE_ALARMS } from './init/guideAlarm.js';
 
 async function createUsers() {
   console.log('Creating user reader');
@@ -72,6 +73,17 @@ async function createMechanism() {
   });
 }
 
+async function createGuideAlarms() {
+  console.log('Creating guide alarms');
+  for (const guideAlarm of INITIAL_GUIDE_ALARMS) {
+    await prisma.guideAlarm.upsert({
+      where: { wfs: guideAlarm.wfs },
+      update: guideAlarm,
+      create: guideAlarm,
+    });
+  }
+}
+
 export async function write() {
   await createUsers();
   await createInstruments();
@@ -80,4 +92,5 @@ export async function write() {
   await createConfiguration();
   await createGuideLoopInfo();
   await createMechanism();
+  await createGuideAlarms();
 }

src/typeDefs.ts

@@ -10,6 +10,7 @@ import { RotatorTypeDefs } from './graphql/types/Rotator.js';
 import { SlewFlagsTypeDefs } from './graphql/types/SlewFlags.js';
 import { TargetTypeDefs } from './graphql/types/Target.js';
 import { UserTypeDefs } from './graphql/types/User.js';
+import { GuideAlarmTypeDefs } from './graphql/types/GuideAlarm.js';
 import { DateTimeTypeDefinition, JSONDefinition } from 'graphql-scalars';
 
 export const typeDefs = [
@@ -27,4 +28,5 @@ export const typeDefs = [
   SlewFlagsTypeDefs,
   TargetTypeDefs,
   UserTypeDefs,
+  GuideAlarmTypeDefs,
 ];