More refactoring and integration of standards dataset database

apps/api/src/database/migrate.ts

@@ -16,7 +16,7 @@ function processResults(label: string, { error, results }: MigrationResultSet):
         if (it.status === 'Success') {
             message = `migration ${label} succeeded: "${it.migrationName}"`;
         } else if (it.status === 'Error') {
-            throw new Error(`migration ${label} failed: "${it.migrationName}"`);
+            throw error ?? new Error(`migration ${label} failed: "${it.migrationName}"`);
         }
     });
 

apps/api/src/database/migrations/2026-06-03.ts

@@ -27,11 +27,27 @@ export async function up(db: Kysely<any>): Promise<void> {
         .nullsNotDistinct()
         .execute();
 
+    // TABLE: STANDARDS_DATASETS
+    await db.schema.createTable("standards_datasets")
+        .$call(addDefaultColumns)
+        .addColumn("name", "text", (cb) => cb.notNull().defaultTo(""))
+        .addColumn("data", "jsonb", (cb) => cb.notNull())
+        .execute();
+
     // TABLE: STANDARDS_CONFIGS
     await db.schema.createTable("standards_configs")
         .$call(addDefaultColumns)
+        .addColumn("name", "text", (cb) => cb.notNull().defaultTo(""))
         .addColumn("parameters", "jsonb", (cb) => cb.notNull())
         .addColumn("is_selected", "boolean", (cb) => cb.notNull().defaultTo(false))
+        .addColumn("dataset_id", "bigint", (cb) => cb.notNull())
+        .addForeignKeyConstraint(
+            "fk_standards_configs_dataset_id",
+            ["dataset_id"],
+            "standards_datasets",
+            ["id"],
+            (cb) => cb.onDelete("restrict")
+        )
         .execute();
 
     // INDEX: ONE_SELECTED_STANDARDS_CONFIG
@@ -50,9 +66,12 @@ export async function down(db: Kysely<any>): Promise<void> {
     // INDEX: ONE_ACTIVE_PRODUCT_SYNC
     await db.schema.dropIndex("idx_one_active_product_sync").ifExists().execute();
 
+    // INDEX: ONE_SELECTED_STANDARDS_CONFIG
+    await db.schema.dropIndex("idx_one_selected_standards_config").ifExists().execute();
+
     // TABLE: STANDARDS_CONFIGS
     await db.schema.dropTable("standards_configs").ifExists().execute()
 
-    // INDEX: ONE_SELECTED_STANDARDS_CONFIG
+    // TABLE: STANDARDS_DATASETS
-    await db.schema.dropIndex("idx_one_selected_standards_config").ifExists().execute();
+    await db.schema.dropTable("standards_datasets").ifExists().execute()
 }

apps/api/src/scripts/analyze.ts

@@ -1,6 +1,6 @@
 import {
     type Levels,
-    DEFAULT_STANDARDS_DATA,
+    DEFAULT_STANDARDS_DATASET,
 } from "@blade-and-brawn/calculator";
 import { Activity, clamp, Gender, range } from "@blade-and-brawn/domain";
 import { levenbergMarquardt as LM } from "ml-levenberg-marquardt";
@@ -15,7 +15,7 @@ for (const activity of Object.values(Activity)) {
     }
 
     for (const gender of Object.values(Gender)) {
-        const standardsByGender = DEFAULT_STANDARDS_DATA[
+        const standardsByGender = DEFAULT_STANDARDS_DATASET[
             activity
         ].standards.filter((s) => s["metrics"].gender === gender);
         const ages = [...new Set(standardsByGender.map((s) => s.metrics.age))];

apps/api/src/server.ts

@@ -116,16 +116,16 @@ export const app = new Elysia()
                 if (!token || !token.sessionId) throw status(401, "Unauthorized");
                 return { sessionId: token.sessionId.toString() };
             })
-            .put("/config/:id", async ({ params: { id }, body: { standardsConfig } }) => {
+            .put("/config/:id", async ({ params: { id }, body: { datasetId, parameters } }) => {
-                await calculatorService.standards.setConfig(id, standardsConfig);
+                await calculatorService.standards.setConfig(id, datasetId, parameters);
             }, {
                 params: t.Object({ id: t.String() }),
-                body: t.Object({ standardsConfig: StandardsParametersSchema })
+                body: t.Object({ datasetId: t.String(), parameters: StandardsParametersSchema })
             })
-            .post("/config", async ({ body: { standardsConfig } }) => {
+            .post("/config", async ({ body: { datasetId, parameters } }) => {
-                await calculatorService.standards.createConfig(standardsConfig);
+                await calculatorService.standards.createConfig(datasetId, parameters);
             }, {
-                body: t.Object({ standardsConfig: StandardsParametersSchema })
+                body: t.Object({ datasetId: t.String(), parameters: StandardsParametersSchema })
             })
             .post("/config/:id/select", async ({ params: { id } }) => {
                 await calculatorService.standards.selectConfig(id);

apps/api/src/services/calculator.ts

@@ -1,10 +1,10 @@
-import { LevelCalculator, Standards, DEFAULT_STANDARDS_DATA, type StandardsParameters, StandardsParametersSchema } from "@blade-and-brawn/calculator";
+import { LevelCalculator, Standards, DEFAULT_STANDARDS_DATASET, type StandardsParameters, StandardsParametersSchema, StandardsDatasetSchema } from "@blade-and-brawn/calculator";
 import type { ActivityPerformance, Player } from "@blade-and-brawn/domain";
 import { db } from "../database/db";
 import { Value } from "@sinclair/typebox/value";
 import { log } from "../util";
 
-let calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATA));
+let calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATASET));
 
 export class CalculatorService {
     standards: StandardsSubService = new StandardsSubService();
@@ -17,7 +17,8 @@ export class CalculatorService {
 
 class StandardsSubService {
     private static readonly CONFIG_REFRESH_INTERVAL_MS = 30_000;
-    private cachedStandardsConfigData: string | null = null;
+    private cachedParametersStringified: string | null = null;
+    private cachedDatasetId: string | null = null;
     private lastRefreshedAt = 0;
 
     async getSelectedConfig(opt: { skipCache?: boolean } = {}): Promise<StandardsParameters> {
@@ -41,17 +42,17 @@ class StandardsSubService {
         });
     }
 
-    async setConfig(id: string, parameters: StandardsParameters) {
+    async setConfig(id: string, datasetId: string, parameters: StandardsParameters) {
         const result = await db.updateTable("standards_configs")
-            .set({ parameters })
+            .set({ parameters, dataset_id: datasetId })
             .where("id", "=", id)
             .execute();
         if (result[0]?.numUpdatedRows === 0n) throw new Error(`No config with id "${id}"`);
     }
 
-    async createConfig(parameters: StandardsParameters) {
+    async createConfig(datasetId: string, parameters: StandardsParameters) {
         await db.insertInto("standards_configs")
-            .values({ parameters })
+            .values({ parameters, dataset_id: datasetId })
             .execute();
     }
 
@@ -61,17 +62,24 @@ class StandardsSubService {
 
         this.lastRefreshedAt = Date.now();
 
-        const { parameters } = await db.selectFrom("standards_configs")
+        const config = await db.selectFrom("standards_configs")
-            .select(["parameters"])
+            .innerJoin("standards_datasets", "standards_datasets.id", "standards_configs.dataset_id")
-            .where("is_selected", "=", true)
+            .select([
+                "standards_configs.dataset_id as datasetId",
+                "standards_configs.parameters as parameters",
+                "standards_datasets.data as dataset",
+            ])
+            .where("standards_configs.is_selected", "=", true)
             .limit(1)
             .executeTakeFirstOrThrow({ errorConstructor: () => new Error("No standards config selected") });
-        Value.Assert(StandardsParametersSchema, parameters);
+        Value.Assert(StandardsParametersSchema, config.parameters);
+        Value.Assert(StandardsDatasetSchema, config.dataset);
 
-        const standardsConfigData = JSON.stringify(parameters);
+        const parametersStringified = JSON.stringify(config.parameters);
-        if (standardsConfigData === this.cachedStandardsConfigData) return;
+        if (parametersStringified === this.cachedParametersStringified && config.datasetId === this.cachedDatasetId) return;
 
-        calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATA, parameters));
+        calculator = new LevelCalculator(new Standards(config.dataset, config.parameters));
-        this.cachedStandardsConfigData = standardsConfigData;
+        this.cachedParametersStringified = parametersStringified;
+        this.cachedDatasetId = config.datasetId;
     }
 }

apps/portal/src/routes/(app)/calculator/+page.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
     import {
-        DEFAULT_STANDARDS_DATA,
+        DEFAULT_STANDARDS_DATASET,
         Standards,
         type StandardsParameters,
     } from "@blade-and-brawn/calculator";
@@ -15,7 +15,7 @@
 
     let activeTab = $state("standards");
 
-    const defaultStandards = new Standards(DEFAULT_STANDARDS_DATA);
+    const defaultStandards = new Standards(DEFAULT_STANDARDS_DATASET);
 
     let input = $state({
         activity: Activity.BenchPress,
@@ -38,12 +38,15 @@
     });
 
     const allStandards = $derived(
-        new Standards(DEFAULT_STANDARDS_DATA, selected.params),
+        new Standards(DEFAULT_STANDARDS_DATASET, selected.params),
     );
 
     $effect(() => {
         const savedParameters = localStorage.getItem("parameters");
-        if (savedParameters) input = JSON.parse(savedParameters);
+        if (!savedParameters) return;
+
+        const parsed = JSON.parse(savedParameters);
+        if (parsed?.params) input = parsed;
     });
 
     $effect(() => {

packages/calculator/src/index.ts

@@ -5,15 +5,15 @@ import {
     kgToLb,
     lbToKg,
     range,
+    MetricsSchema,
     type Metrics,
     type ActivityPerformance,
     type Player,
-    type StandardUnit,
 } from "@blade-and-brawn/domain";
 import { levenbergMarquardt as LM } from "ml-levenberg-marquardt";
 import { Type, type Static } from "@sinclair/typebox";
 import defaultConfig from "./default-config.json" with { type: "json" };
-import defaultStandardsData from "./data/default-standards.json" with { type: "json" };
+import defaultStandardsDataset from "./data/default-standards.json" with { type: "json" };
 import { getAvgWeight } from "./avg-weights";
 import { Value } from "@sinclair/typebox/value";
 
@@ -32,31 +32,37 @@ export type LevelCalculatorOutput = {
     attributes: Record<Attribute, number>;
 };
 
-export type Levels = Record<string, number>;
+export const LevelsSchema = Type.Record(Type.String(), Type.Number());
+export type Levels = Static<typeof LevelsSchema>;
 
 type NumberMetric = Extract<keyof Metrics, "age" | "weight">;
 
-export interface Standard {
+export const StandardSchema = Type.Object({
-    metrics: Metrics;
+    metrics: MetricsSchema,
-    levels: Levels;
+    levels: LevelsSchema,
-}
+});
+export type Standard = Static<typeof StandardSchema>;
 
-type Generator = {
+const GeneratorSchema = Type.Object({
-    metric: NumberMetric;
+    metric: Type.Union([Type.Literal("age"), Type.Literal("weight")]),
-};
+});
+type Generator = Static<typeof GeneratorSchema>;
 
-export type StandardsData = Record<
+const StandardUnitSchema = Type.Union([Type.Literal("ms"), Type.Literal("cm"), Type.Literal("kg")]);
-    Activity,
+
-    {
+export const StandardsDatasetSchema = Type.Record(
-        metadata: {
+    Type.Enum(Activity),
-            attribute: Attribute;
+    Type.Object({
-            generators: Generator[];
+        metadata: Type.Object({
-            unit: StandardUnit;
+            attribute: Type.Enum(Attribute),
-            name: string;
+            generators: Type.Array(GeneratorSchema),
-        };
+            unit: StandardUnitSchema,
-        standards: Standard[];
+            name: Type.String(),
-    }
+        }),
->;
+        standards: Type.Array(StandardSchema),
+    }),
+);
+export type StandardsDataset = Static<typeof StandardsDatasetSchema>;
 
 const metricPriority = (m: NumberMetric) => {
     if (m === "age") return 0;
@@ -64,7 +70,7 @@ const metricPriority = (m: NumberMetric) => {
     return 2;
 };
 
-export const DEFAULT_STANDARDS_DATA = defaultStandardsData as StandardsData;
+export const DEFAULT_STANDARDS_DATASET = defaultStandardsDataset as StandardsDataset;
 
 export class LevelCalculator {
     readonly standards: Standards;
@@ -237,14 +243,14 @@ export type StandardsParameters = Static<typeof StandardsParametersSchema>;
 
 export class Standards {
     readonly params: StandardsParameters;
-    private standardsData: StandardsData;
+    private standardsData: StandardsDataset;
 
-    constructor(standardsData: StandardsData, params?: Partial<StandardsParameters>) {
+    constructor(dataset: StandardsDataset, params?: Partial<StandardsParameters>) {
         Value.Assert(StandardsParametersSchema, defaultConfig);
         this.params = Object.assign({}, defaultConfig, params);
 
         // prepare data
-        this.standardsData = structuredClone(standardsData);
+        this.standardsData = structuredClone(dataset);
 
         // STRETCH
         for (const activity of Object.values(Activity)) {
@@ -765,7 +771,7 @@ export class Standards {
         for (const activity of Object.keys(this.standardsData) as Activity[]) {
             const standardData = this.standardsData[
                 activity
-            ] as StandardsData[Activity];
+            ] as StandardsDataset[Activity];
             if (standardData.metadata.attribute === attribute) {
                 activities.push(activity as Activity);
             }