feat: locationless transits

Author: Floffah

src/defs/index.ts

@@ -82,17 +82,28 @@ export const houseObject = z
         ref: "HouseObject",
     });
 
-export const planetPositionObject = z
+export const genericPlanetPositionObject = z
     .object({
         id: planetIdEnum,
         name: planetEnum,
         longitude: z.number(),
         latitude: z.number().optional(),
         isRetrograde: z.boolean(),
         degree: z.number().min(0).max(30),
-        houseNumber: z.number().min(1).max(12),
         zodiac: zodiacDetailsObject,
     })
+    .openapi({
+        ref: "GenericPlanetPositionObject",
+    });
+
+export type GenericPlanetPositionObject = z.infer<
+    typeof genericPlanetPositionObject
+>;
+
+export const planetPositionObject = genericPlanetPositionObject
+    .extend({
+        houseNumber: z.number().min(1).max(12),
+    })
     .openapi({
         ref: "PlanetPositionObject",
     });
@@ -103,6 +114,14 @@ export const aspectEnum = z.nativeEnum(Aspect).openapi({
     ref: "Aspect",
 });
 
+export const typeOfAspect = z
+    .enum(["transit-to-natal", "natal-to-natal", "transit-to-transit"])
+    .openapi({
+        ref: "TypeOfAspect",
+    });
+
+export type TypeOfAspect = z.infer<typeof typeOfAspect>;
+
 export const aspectObject = z
     .object({
         planet1: z.object({
@@ -120,11 +139,7 @@ export const aspectObject = z
             name: aspectEnum,
         }),
         orb: z.number(),
-        typeOfAspect: z.enum([
-            "transit-to-natal",
-            "natal-to-natal",
-            "transit-to-transit",
-        ]),
+        typeOfAspect,
     })
     .openapi({
         ref: "AspectObject",

src/defs/responses.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 
 import {
     aspectObject,
+    genericPlanetPositionObject,
     houseObject,
     ingressObject,
     planetEnum,
@@ -52,6 +53,40 @@ export type CalculateDailyTransitsResponse = z.infer<
     typeof calculateDailyTransitsResponse
 >;
 
+export const calculateGenericChartResponse = z
+    .object({
+        signs: z.object({
+            sun: zodiacSignObject,
+            moon: zodiacMoonSignObject,
+        }),
+        planets: z.array(genericPlanetPositionObject),
+        aspects: z.array(aspectObject),
+        declinations: z.array(aspectObject),
+    })
+    .openapi({
+        ref: "CalculateGenericChartResponse",
+    });
+
+export type CalculateGenericChartResponse = z.infer<
+    typeof calculateGenericChartResponse
+>;
+
+export const calculateGenericTransitChartResponse = z
+    .object({
+        chart: calculateGenericChartResponse,
+        notableEvents: z.object({
+            retrogradePlanets: z.array(planetEnum),
+            ingresses: z.array(ingressObject),
+        }),
+    })
+    .openapi({
+        ref: "CalculateGenericTransitChartResponse",
+    });
+
+export type CalculateGenericTransitChartResponse = z.infer<
+    typeof calculateGenericTransitChartResponse
+>;
+
 export const errorResponse = z
     .object({
         success: z.literal(false),

src/index.ts

@@ -10,9 +10,11 @@ import {
     baseResponse,
     calculateBirthChartResponse,
     calculateDailyTransitsResponse,
+    calculateGenericTransitChartResponse,
     errorResponse,
 } from "@/defs/responses.ts";
 import { calculateBirthChart } from "@/lib/birthCharts/calculateBirthChart.ts";
+import { calculateGenericTransitChart } from "@/lib/calculateGenericChart.ts";
 import { calculateTransitsForDay } from "@/lib/calculateTransitsForDay.ts";
 import { setSwissephPath } from "@/lib/swisseph.ts";
 
@@ -78,12 +80,14 @@ app.get(
                 .number()
                 .min(0)
                 .max(23)
+                .default(0)
                 .optional()
                 .describe("The UTC hour of birth"),
             minute: z.coerce
                 .number()
                 .min(0)
                 .max(59)
+                .default(0)
                 .optional()
                 .describe("The UTC minute of birth"),
             latitude: z.coerce
@@ -180,12 +184,14 @@ app.get(
                 .number()
                 .min(0)
                 .max(59)
+                .default(0)
                 .optional()
                 .describe("The UTC minute of birth"),
             birthHour: z.coerce
                 .number()
                 .min(0)
                 .max(23)
+                .default(0)
                 .optional()
                 .describe("The UTC hour of birth"),
             birthLatitude: z.coerce
@@ -299,6 +305,97 @@ app.get(
     },
 );
 
+app.get(
+    "/generic-chart",
+    describeRoute({
+        operationId: "calculateGenericTransitChart",
+        description:
+            "This endpoint calculates the transits for a given date but does not require a location or birth data.\n\n**Do not use this for personalised horoscopes**",
+        summary: "Calculate a generic transit chart",
+        responses: {
+            200: {
+                description: "OK",
+                content: {
+                    "application/json": {
+                        schema: resolver(
+                            baseResponse.extend({
+                                data: calculateGenericTransitChartResponse,
+                            }),
+                        ),
+                    },
+                },
+            },
+            400: {
+                description: "User Error",
+                content: {
+                    "application/json": {
+                        schema: resolver(errorResponse),
+                    },
+                },
+            },
+        },
+    }),
+    validator(
+        "query",
+        z.object({
+            year: z.coerce
+                .number()
+                .min(1900)
+                .max(2100)
+                .describe("The UTC year to calculate transits for"),
+            month: z.coerce
+                .number()
+                .min(1)
+                .max(12)
+                .describe(
+                    "The UTC month to calculate transits for. NOT zero-indexed",
+                ),
+            day: z.coerce
+                .number()
+                .min(1)
+                .max(31)
+                .describe("The UTC day to calculate transits for"),
+            hour: z.coerce
+                .number()
+                .min(0)
+                .max(23)
+                .default(12)
+                .optional()
+                .describe("The UTC hour to calculate transits for"),
+            minute: z.coerce
+                .number()
+                .min(0)
+                .max(59)
+                .default(0)
+                .optional()
+                .describe("The UTC minute to calculate transits for"),
+        }),
+    ),
+    async (c) => {
+        const { year, month, day, hour, minute } = c.req.valid("query");
+
+        const transitDate = new Date(
+            Date.UTC(year, month - 1, day, hour ?? 12, minute ?? 0),
+        );
+
+        const transits = calculateGenericTransitChart(transitDate);
+
+        if (transits.isErr()) {
+            return c.json(
+                {
+                    error: transits.error,
+                },
+                500,
+            );
+        }
+
+        return c.json({
+            success: true,
+            data: transits.value,
+        });
+    },
+);
+
 const openapiServers = [
     {
         description: "Production server",

src/lib/birthCharts/calculateBirthChart.ts

@@ -6,7 +6,7 @@ import { calculateHouses } from "@/lib/birthCharts/calculateHouses.ts";
 import { getAnglesForDate } from "@/lib/calculateAngles.ts";
 import { getAspectsForDate } from "@/lib/calculateAspects.ts";
 import { getDeclinationsForDate } from "@/lib/calculateDeclinations.ts";
-import { getPlanetaryPositionsForDate } from "@/lib/calculatePlanetPositions.ts";
+import { getPlanetaryPositionsForDateAndLocation } from "@/lib/calculatePlanetPositions.ts";
 import { calculateSigns } from "@/lib/calculateSigns.ts";
 import { rad } from "@/lib/degrees.ts";
 
@@ -36,7 +36,7 @@ export function calculateBirthChart(
         return houses;
     }
 
-    const planetPositions = getPlanetaryPositionsForDate(
+    const planetPositions = getPlanetaryPositionsForDateAndLocation(
         jde,
         latAngle,
         lonAngle,

src/lib/calculateAspects.ts

@@ -1,10 +1,10 @@
 import * as astronomia from "astronomia";
 import { Err, Result, ok } from "neverthrow";
 
-import type { AspectObject } from "@/defs";
+import type { AspectObject, TypeOfAspect } from "@/defs";
 import { Aspect, Planet, PlanetId } from "@/defs/enums.ts";
 import { getAnglesForDate } from "@/lib/calculateAngles.ts";
-import { getPlanetaryPositionsForDate } from "@/lib/calculatePlanetPositions.ts";
+import { getPlanetaryPositionsForDateAndLocation } from "@/lib/calculatePlanetPositions.ts";
 import type { ExtractError } from "@/types/neverthrow.ts";
 
 const ASPECTS = [
@@ -23,6 +23,7 @@ const ASPECTS = [
 
 export function computeAspects(
     celestialBodies: { id: PlanetId; name: Planet; longitude: number }[],
+    typeOfAspect: TypeOfAspect = "natal-to-natal",
 ) {
     const aspects: AspectObject[] = [];
 
@@ -44,7 +45,7 @@ export function computeAspects(
                         planet2: { id: body2.id, name: body2.name },
                         aspect: { id: aspect.id, name: aspect.name },
                         orb: orb,
-                        typeOfAspect: "natal-to-natal",
+                        typeOfAspect,
                     });
                     break;
                 }
@@ -100,7 +101,11 @@ export function getAspectsForDate(
     lat: astronomia.sexagesimal.Angle,
     lon: astronomia.sexagesimal.Angle,
 ) {
-    const planetResults = getPlanetaryPositionsForDate(jde, lat, lon);
+    const planetResults = getPlanetaryPositionsForDateAndLocation(
+        jde,
+        lat,
+        lon,
+    );
     const angleResults = getAnglesForDate(jde, lat, lon);
 
     if (planetResults.isErr() || angleResults.isErr()) {