@nickchristensen/cliftin 1.0.2

package/dist/lib/repositories/workouts.js

@@ -0,0 +1,128 @@
+import { formatExerciseDisplayName } from '../names.js';
+import { normalizeRpe } from '../rpe.js';
+import { appleSecondsToIso, dateRangeToAppleSeconds } from '../time.js';
+import { convertKgToDisplayVolume, convertKgToDisplayWeight, resolveGlobalWeightUnit } from '../units.js';
+import { resolveIdOrName } from './selectors.js';
+function asBool(value) {
+    return value === 1;
+}
+export async function listWorkouts(db, filters) {
+    const dateRange = dateRangeToAppleSeconds({ from: filters.from, on: filters.on, to: filters.to });
+    let query = db
+        .selectFrom('ZWORKOUTRESULT as wr')
+        .leftJoin('ZROUTINE as r', 'r.Z_PK', 'wr.ZROUTINE')
+        .leftJoin('ZPERIOD as per', 'per.Z_PK', 'r.ZPERIOD')
+        .leftJoin('ZWORKOUTPLAN as pDirect', 'pDirect.Z_PK', 'r.ZWORKOUTPLAN')
+        .leftJoin('ZWORKOUTPLAN as pFromPeriod', 'pFromPeriod.Z_PK', 'per.ZWORKOUTPLAN')
+        .select([
+        'wr.Z_PK as id',
+        'wr.ZSTARTDATE as startDate',
+        'wr.ZDURATION as duration',
+        'wr.ZROUTINENAME as routineNameFromResult',
+        'r.ZNAME as routineNameFromPlan',
+        'pDirect.ZNAME as programNameDirect',
+        'pFromPeriod.ZNAME as programNameFromPeriod',
+    ]);
+    if (filters.program) {
+        const programId = await resolveIdOrName(db, 'ZWORKOUTPLAN', filters.program);
+        query = query.where((eb) => eb.or([eb('r.ZWORKOUTPLAN', '=', programId), eb('per.ZWORKOUTPLAN', '=', programId)]));
+    }
+    if (filters.routine) {
+        const routineId = await resolveIdOrName(db, 'ZROUTINE', filters.routine);
+        query = query.where('wr.ZROUTINE', '=', routineId);
+    }
+    if (dateRange.from !== undefined)
+        query = query.where('wr.ZSTARTDATE', '>=', dateRange.from);
+    if (dateRange.to !== undefined)
+        query = query.where('wr.ZSTARTDATE', '<=', dateRange.to);
+    query = query.orderBy('wr.ZSTARTDATE', 'desc');
+    if (filters.limit !== undefined) {
+        query = query.limit(filters.limit);
+    }
+    const rows = await query.execute();
+    return rows.map((row) => ({
+        date: appleSecondsToIso(row.startDate),
+        duration: row.duration,
+        id: row.id,
+        program: row.programNameDirect ?? row.programNameFromPeriod,
+        routine: row.routineNameFromResult ?? row.routineNameFromPlan,
+    }));
+}
+export async function getWorkoutDetail(db, workoutId) {
+    const unitPreference = await resolveGlobalWeightUnit(db);
+    const workout = await db
+        .selectFrom('ZWORKOUTRESULT as wr')
+        .leftJoin('ZROUTINE as r', 'r.Z_PK', 'wr.ZROUTINE')
+        .leftJoin('ZPERIOD as per', 'per.Z_PK', 'r.ZPERIOD')
+        .leftJoin('ZWORKOUTPLAN as pDirect', 'pDirect.Z_PK', 'r.ZWORKOUTPLAN')
+        .leftJoin('ZWORKOUTPLAN as pFromPeriod', 'pFromPeriod.Z_PK', 'per.ZWORKOUTPLAN')
+        .select([
+        'wr.Z_PK as id',
+        'wr.ZSTARTDATE as startDate',
+        'wr.ZDURATION as duration',
+        'wr.ZROUTINENAME as routineNameFromResult',
+        'r.ZNAME as routineNameFromPlan',
+        'pDirect.ZNAME as programNameDirect',
+        'pFromPeriod.ZNAME as programNameFromPeriod',
+    ])
+        .where('wr.Z_PK', '=', workoutId)
+        .executeTakeFirst();
+    if (!workout)
+        throw new Error(`Workout not found: ${workoutId}`);
+    const exerciseRows = await db
+        .selectFrom('ZEXERCISERESULT as er')
+        .leftJoin('ZEXERCISECONFIGURATION as ec', 'ec.Z_PK', 'er.ZCONFIGURATION')
+        .leftJoin('ZEXERCISEINFORMATION as ei', 'ei.Z_PK', 'ec.ZINFORMATION')
+        .select(['er.Z_PK as exerciseResultId', 'ei.Z_PK as exerciseId', 'ei.ZISUSERCREATED as isUserCreated', 'ei.ZNAME as exerciseName'])
+        .where('er.ZWORKOUT', '=', workoutId)
+        .orderBy('er.Z_FOK_WORKOUT', 'asc')
+        .orderBy('er.Z_PK', 'asc')
+        .execute();
+    const exerciseResultIds = exerciseRows.map((row) => row.exerciseResultId);
+    const setRows = exerciseResultIds.length === 0
+        ? []
+        : await db
+            .selectFrom('ZGYMSETRESULT')
+            .select([
+            'Z_PK as id',
+            'ZEXERCISE as exerciseResultId',
+            'ZREPS as reps',
+            'ZRPE as rpe',
+            'ZWEIGHT as weight',
+            'ZTIME as timeSeconds',
+            'ZVOLUME as volume',
+        ])
+            .where('ZEXERCISE', 'in', exerciseResultIds)
+            .orderBy('Z_FOK_EXERCISE', 'asc')
+            .orderBy('Z_PK', 'asc')
+            .execute();
+    const setsByExercise = new Map();
+    for (const row of setRows) {
+        if (row.exerciseResultId === null)
+            continue;
+        const current = setsByExercise.get(row.exerciseResultId) ?? [];
+        current.push({
+            id: row.id,
+            reps: row.reps,
+            rpe: normalizeRpe(row.rpe),
+            timeSeconds: row.timeSeconds,
+            volume: convertKgToDisplayVolume(row.volume, unitPreference),
+            weight: convertKgToDisplayWeight(row.weight, unitPreference),
+        });
+        setsByExercise.set(row.exerciseResultId, current);
+    }
+    const exercises = exerciseRows.map((row) => ({
+        exerciseId: row.exerciseId,
+        exerciseResultId: row.exerciseResultId,
+        name: formatExerciseDisplayName(row.exerciseName, asBool(row.isUserCreated)),
+        sets: setsByExercise.get(row.exerciseResultId) ?? [],
+    }));
+    return {
+        date: appleSecondsToIso(workout.startDate),
+        duration: workout.duration,
+        exercises,
+        id: workout.id,
+        program: workout.programNameDirect ?? workout.programNameFromPeriod,
+        routine: workout.routineNameFromResult ?? workout.routineNameFromPlan,
+    };
+}

package/dist/lib/rpe.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_RPE_SENTINEL = 16;
+export declare function normalizeRpe(rpe: null | number): null | number;

package/dist/lib/rpe.js

@@ -0,0 +1,4 @@
+export const DEFAULT_RPE_SENTINEL = 16;
+export function normalizeRpe(rpe) {
+    return rpe === DEFAULT_RPE_SENTINEL ? null : rpe;
+}

package/dist/lib/time.d.ts

@@ -0,0 +1,10 @@
+export type DateFilterInput = {
+    from?: string;
+    on?: string;
+    to?: string;
+};
+export declare function appleSecondsToIso(value: null | number): null | string;
+export declare function dateRangeToAppleSeconds(input: DateFilterInput): {
+    from?: number;
+    to?: number;
+};

package/dist/lib/time.js

@@ -0,0 +1,49 @@
+import { endOfDay, formatISO, isAfter, isValid, parse, startOfDay } from 'date-fns';
+const APPLE_EPOCH_UNIX_OFFSET_SECONDS = 978_307_200;
+export function appleSecondsToIso(value) {
+    if (value === null || value === undefined)
+        return null;
+    return formatISO(appleSecondsToDate(value));
+}
+function parseLocalDate(value) {
+    const date = parse(value, 'yyyy-MM-dd', new Date());
+    if (!isValid(date)) {
+        throw new Error(`Invalid date format: ${value}. Use YYYY-MM-DD.`);
+    }
+    // Guard against partial parse behavior; require exact YYYY-MM-DD roundtrip.
+    if (formatISO(date, { representation: 'date' }) !== value) {
+        throw new Error(`Invalid date format: ${value}. Use YYYY-MM-DD.`);
+    }
+    return date;
+}
+function appleSecondsToDate(value) {
+    return new Date((value + APPLE_EPOCH_UNIX_OFFSET_SECONDS) * 1000);
+}
+function dateToAppleSeconds(date) {
+    return date.getTime() / 1000 - APPLE_EPOCH_UNIX_OFFSET_SECONDS;
+}
+export function dateRangeToAppleSeconds(input) {
+    if (input.on) {
+        const start = startOfDay(parseLocalDate(input.on));
+        const end = endOfDay(start);
+        return {
+            from: dateToAppleSeconds(start),
+            to: dateToAppleSeconds(end),
+        };
+    }
+    const output = {};
+    if (input.from) {
+        const start = startOfDay(parseLocalDate(input.from));
+        output.from = dateToAppleSeconds(start);
+    }
+    if (input.to) {
+        const end = endOfDay(parseLocalDate(input.to));
+        output.to = dateToAppleSeconds(end);
+    }
+    if (output.from !== undefined &&
+        output.to !== undefined &&
+        isAfter(appleSecondsToDate(output.from), appleSecondsToDate(output.to))) {
+        throw new Error('Invalid date range: --from must be before or equal to --to.');
+    }
+    return output;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,123 @@
+export type IdName = {
+    id: number;
+    name: string;
+};
+export type ProgramSummary = {
+    dateAdded: null | string;
+    id: number;
+    isActive: boolean;
+    isTemplate: boolean;
+    name: string;
+};
+export type PlannedSet = {
+    id: null | number;
+    reps: null | number;
+    rpe: null | number;
+    timeSeconds: null | number;
+    weight: null | number;
+};
+export type PlannedExercise = {
+    exerciseConfigId: number;
+    id: null | number;
+    name: null | string;
+    plannedReps: null | number;
+    plannedSets: null | number;
+    plannedTimeSeconds: null | number;
+    plannedWeight: null | number;
+    sets: PlannedSet[];
+};
+export type ProgramRoutine = {
+    exercises: PlannedExercise[];
+    id: number;
+    name: null | string;
+};
+export type ProgramWeek = {
+    id: number;
+    routines: ProgramRoutine[];
+};
+export type ProgramDetailTree = {
+    program: ProgramSummary;
+    weeks: ProgramWeek[];
+};
+export type WorkoutSummary = {
+    date: null | string;
+    duration: null | number;
+    id: number;
+    program: null | string;
+    routine: null | string;
+};
+export type WorkoutSet = {
+    id: number;
+    reps: null | number;
+    rpe: null | number;
+    timeSeconds: null | number;
+    volume: null | number;
+    weight: null | number;
+};
+export type WorkoutExerciseDetail = {
+    exerciseId: null | number;
+    exerciseResultId: number;
+    name: null | string;
+    sets: WorkoutSet[];
+};
+export type WorkoutDetail = {
+    date: null | string;
+    duration: null | number;
+    exercises: WorkoutExerciseDetail[];
+    id: number;
+    program: null | string;
+    routine: null | string;
+};
+export type ExerciseSummary = {
+    equipment: null | string;
+    id: number;
+    lastPerformed: null | string;
+    name: null | string;
+    primaryMuscles: null | string;
+    secondaryMuscles: null | string;
+    supports1RM: boolean;
+    timerBased: boolean;
+    timesPerformed: number;
+};
+export type ExerciseHistoryRow = {
+    date: null | string;
+    routine: null | string;
+    sets: number;
+    topReps: null | number;
+    topWeight: null | number;
+    totalReps: number;
+    volume: number;
+    workoutId: number;
+};
+export type ExerciseHistorySet = {
+    reps: null | number;
+    setId: number;
+    timeSeconds: null | number;
+    volume: null | number;
+    weight: null | number;
+};
+export type ExerciseHistoryWithSetsRow = {
+    date: null | string;
+    routine: null | string;
+    sets: ExerciseHistorySet[];
+    topReps: null | number;
+    topWeight: null | number;
+    totalReps: number;
+    volume: number;
+    workoutId: number;
+};
+export type ExerciseDetail = {
+    defaultProgressMetric: null | string;
+    equipment: null | string;
+    id: number;
+    lastHistoryEntry: ExerciseHistoryRow | null;
+    name: null | string;
+    perceptionScale: null | string;
+    primaryMuscles: null | string;
+    recentRoutines: string[];
+    secondaryMuscles: null | string;
+    supports1RM: boolean;
+    timerBased: boolean;
+    totalRoutines: number;
+    totalWorkouts: number;
+};

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/units.d.ts

@@ -0,0 +1,16 @@
+import { Kysely } from 'kysely';
+import { DatabaseSchema } from './db.js';
+export type UnitPreference = 'imperial' | 'metric' | 'unknown';
+export type WeightDisplayUnit = 'kg' | 'lb';
+export type WeightValueWithUnit = {
+    unit: WeightDisplayUnit;
+    value: null | number;
+};
+export declare function convertKgToDisplayWeight(weight: null | number, unitPreference: UnitPreference): null | number;
+export declare function convertDisplayWeightToKg(weight: number, unitPreference: UnitPreference): number;
+export declare function convertKgToDisplayVolume(volume: null | number, unitPreference: UnitPreference): null | number;
+export declare function weightUnitLabel(unitPreference: UnitPreference): WeightDisplayUnit;
+export declare function withWeightUnit(weight: null | number, unitPreference: UnitPreference): WeightValueWithUnit;
+export declare function resolveGlobalWeightUnit(db: Kysely<DatabaseSchema>): Promise<UnitPreference>;
+export declare function resolveProgramWeightUnit(db: Kysely<DatabaseSchema>, programId: number): Promise<UnitPreference>;
+export declare function resolveExerciseWeightUnit(db: Kysely<DatabaseSchema>, exerciseId: number): Promise<UnitPreference>;

package/dist/lib/units.js

@@ -0,0 +1,81 @@
+const KG_TO_LB_MULTIPLIER = 2.2;
+function normalizeUnitPreference(value) {
+    if (!value)
+        return 'unknown';
+    const normalized = value.trim().toLowerCase();
+    if (normalized.includes('imperial') || normalized === 'lbs' || normalized === 'lb')
+        return 'imperial';
+    if (normalized.includes('metric') || normalized === 'kg')
+        return 'metric';
+    return 'unknown';
+}
+export function convertKgToDisplayWeight(weight, unitPreference) {
+    if (weight === null)
+        return null;
+    if (unitPreference !== 'imperial')
+        return weight;
+    return Number((weight * KG_TO_LB_MULTIPLIER).toFixed(2));
+}
+export function convertDisplayWeightToKg(weight, unitPreference) {
+    if (unitPreference !== 'imperial')
+        return weight;
+    return Number((weight / KG_TO_LB_MULTIPLIER).toFixed(6));
+}
+export function convertKgToDisplayVolume(volume, unitPreference) {
+    if (volume === null)
+        return null;
+    if (unitPreference !== 'imperial')
+        return volume;
+    return Number((volume * KG_TO_LB_MULTIPLIER).toFixed(2));
+}
+export function weightUnitLabel(unitPreference) {
+    return unitPreference === 'imperial' ? 'lb' : 'kg';
+}
+export function withWeightUnit(weight, unitPreference) {
+    return {
+        unit: weightUnitLabel(unitPreference),
+        value: weight,
+    };
+}
+export async function resolveGlobalWeightUnit(db) {
+    const settings = await db
+        .selectFrom('ZSETTINGS')
+        .select('ZMEASURMENTUNIT as unit')
+        .executeTakeFirst();
+    return normalizeUnitPreference(settings?.unit ?? null);
+}
+export async function resolveProgramWeightUnit(db, programId) {
+    const settingsUnit = await resolveGlobalWeightUnit(db);
+    if (settingsUnit !== 'unknown')
+        return settingsUnit;
+    const equipmentUnits = await db
+        .selectFrom('ZROUTINE as r')
+        .leftJoin('ZPERIOD as p', 'p.Z_PK', 'r.ZPERIOD')
+        .leftJoin('Z_12ROUTINES as j', 'j.Z_28ROUTINES', 'r.Z_PK')
+        .leftJoin('ZEXERCISECONFIGURATION as ec', 'ec.Z_PK', 'j.Z_12EXERCISES')
+        .leftJoin('ZEXERCISEINFORMATION as ei', 'ei.Z_PK', 'ec.ZINFORMATION')
+        .leftJoin('ZEQUIPMENT2 as eq', 'eq.Z_PK', 'ei.ZEQUIPMENT')
+        .select('eq.ZMEASURMENTUNIT as unit')
+        .where((eb) => eb.or([eb('p.ZWORKOUTPLAN', '=', programId), eb('r.ZWORKOUTPLAN', '=', programId)]))
+        .where('r.ZSOFTDELETED', 'is not', 1)
+        .where('eq.ZMEASURMENTUNIT', 'is not', null)
+        .execute();
+    const normalized = new Set(equipmentUnits.map((row) => normalizeUnitPreference(row.unit)));
+    if (normalized.has('imperial'))
+        return 'imperial';
+    if (normalized.has('metric'))
+        return 'metric';
+    return 'unknown';
+}
+export async function resolveExerciseWeightUnit(db, exerciseId) {
+    const settingsUnit = await resolveGlobalWeightUnit(db);
+    if (settingsUnit !== 'unknown')
+        return settingsUnit;
+    const row = await db
+        .selectFrom('ZEXERCISEINFORMATION as ei')
+        .leftJoin('ZEQUIPMENT2 as eq', 'eq.Z_PK', 'ei.ZEQUIPMENT')
+        .select('eq.ZMEASURMENTUNIT as unit')
+        .where('ei.Z_PK', '=', exerciseId)
+        .executeTakeFirst();
+    return normalizeUnitPreference(row?.unit ?? null);
+}