Software/platform
1
1
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

More refactoring and integration of standards dataset database

Browse Source
This commit is contained in:
Dominic Ferrando
2026-07-04 14:11:13 -04:00
parent 9e1025e119
commit 01878a8e03
7 changed files with 93 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/api/src/database/migrate.ts
+1 -1
View File
@@ -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
+21 -2
View File
@@ -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
await db.schema.dropIndex("idx_one_selected_standards_config").ifExists().execute();
// TABLE: STANDARDS_DATASETS
await db.schema.dropTable("standards_datasets").ifExists().execute()
}
apps/api/src/scripts/analyze.ts
+2 -2
View File
@@ -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
+6 -6
View File
@@ -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 } }) => {
await calculatorService.standards.setConfig(id, standardsConfig);
.put("/config/:id", async ({ params: { id }, body: { datasetId, parameters } }) => {
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 } }) => {
await calculatorService.standards.createConfig(standardsConfig);
.post("/config", async ({ body: { datasetId, parameters } }) => {
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
+23 -15
View File
@@ -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")
.select(["parameters"])
.where("is_selected", "=", true)
const config = await db.selectFrom("standards_configs")
.innerJoin("standards_datasets", "standards_datasets.id", "standards_configs.dataset_id")
.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);
if (standardsConfigData === this.cachedStandardsConfigData) return;
const parametersStringified = JSON.stringify(config.parameters);
if (parametersStringified === this.cachedParametersStringified && config.datasetId === this.cachedDatasetId) return;
calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATA, parameters));
this.cachedStandardsConfigData = standardsConfigData;
calculator = new LevelCalculator(new Standards(config.dataset, config.parameters));
this.cachedParametersStringified = parametersStringified;
this.cachedDatasetId = config.datasetId;
}
}
apps/portal/src/routes/(app)/calculator/+page.svelte
+7 -4
View File
@@ -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
+33 -27
View File
@@ -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 {
metrics: Metrics;
levels: Levels;
}
export const StandardSchema = Type.Object({
metrics: MetricsSchema,
levels: LevelsSchema,
});
export type Standard = Static<typeof StandardSchema>;
type Generator = {
metric: NumberMetric;
};
const GeneratorSchema = Type.Object({
metric: Type.Union([Type.Literal("age"), Type.Literal("weight")]),
});
type Generator = Static<typeof GeneratorSchema>;
export type StandardsData = Record<
Activity,
{
metadata: {
attribute: Attribute;
generators: Generator[];
unit: StandardUnit;
name: string;
};
standards: Standard[];
}
>;
const StandardUnitSchema = Type.Union([Type.Literal("ms"), Type.Literal("cm"), Type.Literal("kg")]);
export const StandardsDatasetSchema = Type.Record(
Type.Enum(Activity),
Type.Object({
metadata: Type.Object({
attribute: Type.Enum(Attribute),
generators: Type.Array(GeneratorSchema),
unit: StandardUnitSchema,
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);
}