@optolith/database-schema 0.68.1 → 0.69.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.69.0](https://github.com/Optolith/database-schema/compare/v0.68.1...v0.69.0) (2026-09-27)
+
+### ⚠ BREAKING CHANGES
+
+* ancestor blood advantage cache name typo
+
+### Features
+
+* derived trade secrets cache ([18e1ea8](https://github.com/Optolith/database-schema/commit/18e1ea889894108647f3b844c6f84f19beb8eac1))
+
+### Bug Fixes
+
+* ancestor blood advantage cache name typo ([b7d2592](https://github.com/Optolith/database-schema/commit/b7d2592cf6f8542761fa0f46b76630f57011047e))
 ## [0.68.1](https://github.com/Optolith/database-schema/compare/v0.68.0...v0.68.1) (2026-09-27)
 
 ### Features

package/lib/cache/index.d.ts

@@ -4,11 +4,13 @@ import { type ActivatableSelectOptionsCache, type ResolvedSelectOption, type Res
 import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts";
 import { type MagicalAndBlessedAdvantagesAndDisadvantagesCache } from "./magicalAndBlessedAdvantagesAndDisadvantages.ts";
 import { type NewApplicationsAndUsesCache, type ResolvedNewSkillApplication, type ResolvedSkillUse } from "./newApplicationsAndUses.ts";
+import { type DerivedTradeSecretsCache } from "./tradeSecrets.ts";
 /**
  * Identifiers of specific entries in the database that are used for creating the cache.
  */
 export type IdMap = {
     Advantage: Record<"Blessed" | "Spellcaster", string>;
+    GeneralSpecialAbility: Record<"Weaponsmith" | "Armorer", string>;
     MagicalSpecialAbility: Record<"PropertyKnowledge", string>;
     KarmaSpecialAbility: Record<"AspectKnowledge", string>;
 };
@@ -17,7 +19,8 @@ export type IdMap = {
  */
 export type Cache = {
     activatableSelectOptions: ActivatableSelectOptionsCache;
-    sncestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    ancestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    derivedTradeSecrets: DerivedTradeSecretsCache;
     magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantagesCache;
     newApplicationsAndUses: NewApplicationsAndUsesCache;
 };

package/lib/cache/index.js

@@ -2,6 +2,7 @@ import { activatableSelectOptionsCacheBuilder, } from "./activatableSelectOption
 import { buildAncestorBloodAdvantagesCache, } from "./ancestorBloodAdvantages.js";
 import { buildMagicalAndBlessedAdvantagesAndDisadvantagesCache, } from "./magicalAndBlessedAdvantagesAndDisadvantages.js";
 import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
+import { buildDerivedTradeSecretsCache } from "./tradeSecrets.js";
 /**
  * Creates the cache by precomputing all necessary data from the database.
  * @param db The TSONDB instance containing the database.
@@ -10,12 +11,14 @@ import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
  */
 export const createCache = (db, idMap) => {
     const activatableSelectOptions = activatableSelectOptionsCacheBuilder(db, idMap);
-    const sncestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const ancestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const derivedTradeSecrets = buildDerivedTradeSecretsCache(db, idMap);
     const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, idMap);
     const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, idMap, activatableSelectOptions);
     return {
         activatableSelectOptions,
-        sncestorBloodAdvantages,
+        ancestorBloodAdvantages,
+        derivedTradeSecrets,
         magicalAndBlessedAdvantagesAndDisadvantages,
         newApplicationsAndUses,
     };

package/lib/cache/tradeSecrets.d.ts

@@ -0,0 +1,23 @@
+import { Case } from "tsondb/schema/gen";
+import type { ArmorComplexity, Complexity, EntityMap, EquipmentIdentifier, TradeSecret } from "../../gen/types.js";
+import type { CacheBuilder } from "./internal.ts";
+type EquipmentEntitiesWithComplexities = {
+    [K in EquipmentIdentifier["kind"]]: EntityMap[K] extends {
+        complexity?: Complexity | ArmorComplexity;
+    } ? K : never;
+}[EquipmentIdentifier["kind"]];
+type HerbaryEntitiesWithTradeSecrets = "Disease" | "Elixir" | "HerbalAid" | "Poison";
+export type DerivedTradeSecretsCache = {
+    equipment: {
+        [K in EquipmentEntitiesWithComplexities]: Record<string, TradeSecret>;
+    };
+    herbary: {
+        [K in HerbaryEntitiesWithTradeSecrets]: Record<string, TradeSecret>;
+    };
+    all: {
+        id: Case<"TradeSecret" | EquipmentEntitiesWithComplexities | HerbaryEntitiesWithTradeSecrets, string>;
+        content: TradeSecret;
+    }[];
+};
+export declare const buildDerivedTradeSecretsCache: CacheBuilder<DerivedTradeSecretsCache>;
+export {};

package/lib/cache/tradeSecrets.js

@@ -0,0 +1,126 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { Case } from "tsondb/schema/gen";
+const emptyDerivedEquipmentTradeSecretsCache = {
+    Armor: {},
+    BandageOrRemedy: {},
+    Book: {},
+    CeremonialItem: {},
+    Clothes: {},
+    Container: {},
+    IlluminationLightSource: {},
+    IlluminationRefillOrSupply: {},
+    Jewelry: {},
+    Laboratory: {},
+    Liebesspielzeug: {},
+    LuxuryGood: {},
+    MagicalArtifact: {},
+    MusicalInstrument: {},
+    OrienteeringAid: {},
+    RopeOrChain: {},
+    Stationery: {},
+    ThievesTool: {},
+    ToolOfTheTrade: {},
+    TravelGearOrTool: {},
+    Vehicle: {},
+    Weapon: {},
+    WeaponAccessory: {},
+};
+const emptyDerivedHerbaryTradeSecretsCache = {
+    Disease: {},
+    Elixir: {},
+    HerbalAid: {},
+    Poison: {},
+};
+export const buildDerivedTradeSecretsCache = (database, idMap) => {
+    const cache = {
+        equipment: emptyDerivedEquipmentTradeSecretsCache,
+        herbary: emptyDerivedHerbaryTradeSecretsCache,
+        all: database.getAllInstanceContainersOfEntity("TradeSecret").map(container => ({
+            id: Case("TradeSecret", container.id),
+            content: container.content,
+        })),
+    };
+    for (const entity of Object.keys(cache.equipment)) {
+        for (const container of database.getAllInstanceContainersOfEntity(entity)) {
+            if (container.content.complexity && container.content.complexity.kind === "Complex") {
+                const derivedTradeSecret = {
+                    ap_value: Case("Fixed", container.content.complexity.Complex.ap_value),
+                    is_secret_knowledge: false,
+                    prerequisites: entity === "Weapon"
+                        ? [
+                            Case("Single", Case("Activatable", {
+                                id: Case("GeneralSpecialAbility", idMap.GeneralSpecialAbility.Weaponsmith),
+                                active: true,
+                            })),
+                        ]
+                        : entity === "Armor"
+                            ? [
+                                Case("Single", Case("Activatable", {
+                                    id: Case("GeneralSpecialAbility", idMap.GeneralSpecialAbility.Armorer),
+                                    active: true,
+                                })),
+                            ]
+                            : undefined,
+                    src: container.content.complexity.Complex.src ?? container.content.src,
+                    translations: Object.fromEntries(Object.entries(container.content.translations).map(([lang, translation]) => [
+                        lang,
+                        {
+                            name: translation.name,
+                        },
+                    ])),
+                };
+                cache.equipment[entity][container.id] = derivedTradeSecret;
+                cache.all.push({
+                    id: Case(entity, container.id),
+                    content: derivedTradeSecret,
+                });
+            }
+        }
+    }
+    const addTradeSecretToHerbaryCache = (entity, container, tradeSecret) => {
+        const derivedTradeSecret = {
+            ap_value: Case("Fixed", tradeSecret.ap_value),
+            is_secret_knowledge: false,
+            prerequisites: tradeSecret.prerequisites,
+            src: tradeSecret.src ?? container.content.src,
+            translations: Object.fromEntries(Object.entries(container.content.translations).map(([lang, translation]) => [
+                lang,
+                {
+                    name: translation.name,
+                },
+            ])),
+        };
+        cache.herbary[entity][container.id] = derivedTradeSecret;
+        cache.all.push({
+            id: Case(entity, container.id),
+            content: derivedTradeSecret,
+        });
+    };
+    for (const entity of Object.keys(emptyDerivedHerbaryTradeSecretsCache)) {
+        switch (entity) {
+            case "Disease":
+            case "Elixir":
+            case "HerbalAid":
+                for (const container of database.getAllInstanceContainersOfEntity(entity)) {
+                    if (container.content.trade_secret) {
+                        addTradeSecretToHerbaryCache(entity, container, container.content.trade_secret);
+                    }
+                }
+                break;
+            case "Poison":
+                for (const container of database.getAllInstanceContainersOfEntity(entity)) {
+                    if (container.content.source_type.kind === "AlchemicalPoison") {
+                        addTradeSecretToHerbaryCache(entity, container, container.content.source_type.AlchemicalPoison.trade_secret);
+                    }
+                    else if (container.content.source_type.kind == "AnimalVenom" &&
+                        container.content.source_type.AnimalVenom.complexity?.kind === "Complex") {
+                        addTradeSecretToHerbaryCache(entity, container, container.content.source_type.AnimalVenom.complexity.Complex);
+                    }
+                }
+                break;
+            default:
+                return assertExhaustive(entity);
+        }
+    }
+    return cache;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.68.1",
+  "version": "0.69.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",