brouberol/5esheets

Visualize and update your D&D 5e character sheets in your browser

5esheets's Issues

Run frontest unit tests in CI

Implement translations, to support multiple languages

Add an API handler to create a new party

Run the SQL migrations at application startup

Right now, the alembic.ini file isn't included in the Docker image, and migrations are left as an exercise to the user. We need to include the config file, and make sure the migrations are run fully automatically at startup.

Setup a CSS preprocessor

Whether we use SASS or LESS is left to @etnbrd to decide <3 Once a decision has been made, we should make sure to integrate it in the build step.

Wonky alignment of sections when on mobile

Setup the Svelte application

Setup a basic Svelte application and integrate it with the FastAPI app, as well as the Makefile/Dockerfile.

Implement client-side authentication

Now that the authentication mechanism is implemented backend-side (see #100), we need to make sure the 5esheet generated API client supports it. Namely, we need to:

• have the user fill a username/password form
• send them via a POST request to /api/login/token, which (if the username/password are correct) will return set-cookie headers containing the JWT access token, as well as a CSRF token
• send the JWT access token any subsequent request cookies, as well as the content of the CSRF cookie in the X-CSRF-TOKEN header

Make sure a character slug is unique with respect to the associated player_id

Two players can have a character with the same name, but one player can't.

Implement the spellbook part of the character sheet

We need to implement the spell book part of the character sheet, allowing us to list all the spells the character knows, the spells they have prepared for you spell DC, the number of prepared spells per day etc.

Define a login API

The login API will take a username/password, and return a JWT with a given TTL. Any subsequent API calls will need to use the JWT has a bearer token.

Actually checking the presence of the JWT on the API calls will be done later.

We should rely on https://fastapi.tiangolo.com/lo/tutorial/security/oauth2-jwt/

Support light/dark system themes

Sort skills according to their translations, to reduce confusion

Reimplement page layout and data update logic in Svelte

We’ll need to reimplement the whole page layout and data update logic in the Svelte app. This is probably a non trivial project that will take time to get right.

Replace caribou by Alembic

Let’s replace Caribou by alembic to enable the automatic generation of migrations as the SQLAlchemy models evolve.

Stabilize the schema of `Character.data` and create a `pydantic` schema to document it up to the clients

The caracteristic modifer macro is rendered once and is replaced in DB by the rendered text

Steps to reproduce:

• Use @int_mod in a textarea (ex: Features)
• Reload the page and re-submit the firm
• @int_mod has now be replaced by the associated value in DB

Replace flask by FastAPI

This will allow us to use asynchronous API handlers, in turn allowing us to serve many requests with little horse power.

Render the markdown content of text fields, and allow their edition

The way this worked in the previous, vanilla-JS app, was:

• each text field that contained markdown was actually invisible, and doubled up by a div containing the rendered markdown content (rendered via https://github.com/markedjs/marked)
• when the focusin event was triggered, the div was hidden, and the text field was shown
• after edition, when the focusout event was triggered, the text field was hidden, and the div was shown

The trick was to make the text field part of the overall form, but not the div. This allowed us to evaluate and render mini macros, such as @int_mod on the fly, and not have the rendered value be saved to DB at the next form submit.

Provide users with dockerfile

Add customizable block to track class-specific resources

Ex: cleric divine interventions, paladin’s divine smite, artificer canon uses, etc.

Import items compendium translations

We could leverage https://gitlab.com/baktov.sugar/foundryvtt-dnd5e-lang-fr-fr/-/blob/master/dnd5e_fr-FR/compendium/dnd5e.items.json to match each item with their associated translations, and fallback to English if it’s not found.

Note: some spells or items don’t yet have an official translation, so the general experience when leveraging recent compendium elements is to have some of them translated and some of them not.

Make sure that the JWT comes from the cookies

This will make sure that the token isn't stored in the browser's localStorage and thus be exposed to the outside world. By having the cookie be httponly, we will also restrict the JS code from accessing it.

We could/should replace our semi-custom JWT implementation by https://indominusbyte.github.io/fastapi-jwt-auth/usage/jwt-in-cookies/

This will also make sure that the client can authenticate transparently, as the backend will answer with a set-cookie HTTP Response header.

Replace peewee by SQLAlchemy

We need to replace peewee by SQLAlchemy to support asynchronous queries (and thus asynchronous API request handling) in the future.

Configure quality checkers for the codebase

• black for formatting
• ruff for linting
• mypy for types

Migrate from click to typer

Click comes along with Flask, when typer is provided by Fastapi. We need to convert the flask db populate command from click to typer.

Add an API handler to create a new player

Import all spells to database

The same way we have imported items to database, we should import all the non-spells along with their translations, so that we can easily link the spell book of one character to actual spell references in the database. This should make it easier for players to add spells to their spell book.

Add tests for the backend API routes

Define a model for items/equipment

This model will be used to represent items hold / equipped by a character. New homebrew items could be created, and we'll need to import the SRD 5e items.

Import SRD 5e items to database

As 5e SRD items are now Creative Commons and that the OGL is no longer in jeopardy, we can safely import them to database for further use by the player.

Introduce a small & simple SQL migration system

Avoid SQLAlchemy/Alembic, as they pull way too much complexity fir this project. Would https://github.com/clutchski/caribou work?

Use ETag headers to force the browser to cache resources

We could rely on ETag headers to force browsers to rely on their own cache to avoid having the server recompute a resource when it hasn't changed.

💡 We could rely on the hash of the last update timestamp of each resource, for example.

Setup dependabot to regularly upgrade Python and JS dependencies

Introduce a way to define settings per env

We should leverage https://fastapi.tiangolo.com/advanced/settings/

Add form to create a new character

Add an API handler to create a new character

Ensure `create_session` starts a transaction if used as a context manager

We’d need to make sure that the default behavior when create_session is used as a context manager is:

1. establish connection
2. Start transaction
3. commit or rollback at exit

Right now I’m not sure we do 2.

Generate a typescript client for the 5esheets API

Cf https://fastapi.tiangolo.com/advanced/generate-clients/

Effect unit tests tests are failing

$ NODE_ENV=prod npm run test                                                                                                                                          12:04:43 PM

> test
> vitest --run


 RUN  v0.32.4 /Users/br/code/5esheets/dnd5esheets/front

 ✓ src/effects/parser/index.test.ts (10)
 ❯ src/effects/index.test.ts (18)
   ❯ apply effect (18)
     ✓ applies a static effect
     ✓ applies a derived effect
     × applies a derived effect which updates from its dependency
     ✓ applies a nested derived effect
     × applies a nested derived effect which updates from its dependency
     ✓ applies a deeply nested derived effect
     × applies a nested derived effect which updates from its dependency
     ✓ applies a non-computed nested derived effect
     × applies a non-computed nested derived effect which updates from its dependency
     ✓ applies a non-computed deeply nested derived effect
     × applies a non-computed deeply nested derived effect which updates from its dependency
     ✓ applies an effect containing a function
     ✓ applies a derived effect containing a function
     × applies a derived effect containing a function which updates from its dependency
     × applies a somewhat complex effect which updates from its dependency
     × applies a somewhat complex effect on a nested target which updates from its dependency
     × applies a nested derived effect on a sibling target which updates from its dependency
     ↓ applies a derived effect containing a function which updates from its dependency [skipped]

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ Failed Tests 9 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a derived effect which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:40:25
     38|       setContext("a", 2);
     39|       expect(context.a).toBe(2);
     40|       expect(context.b).toBe(context.a);
       |                         ^
     41|     }));
     42|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:35:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a nested derived effect which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:55:25
     53|       applyEffect("b := nested.a", context, setContext);
     54|       setContext("nested", "a", 2);
     55|       expect(context.b).toBe(context.nested.a);
       |                         ^
     56|     }));
     57|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:51:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a nested derived effect which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:74:25
     72|       applyEffect("b := deeply.nested.a", context, setContext);
     73|       setContext("deeply", "nested", "a", 2);
     74|       expect(context.b).toBe(context.deeply.nested.a);
       |                         ^
     75|     }));
     76|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:68:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a non-computed nested derived effect which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:89:25
     87|       applyEffect("b := nested[key]", context, setContext);
     88|       setContext("nested", "a", 2);
     89|       expect(context.b).toBe(context.nested.a);
       |                         ^
     90|     }));
     91|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:85:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[4/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a non-computed deeply nested derived effect which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:112:25
    110|       applyEffect("b := nested[key_][key__]", context, setContext);
    111|       setContext("nested", "a_", "a__", 2);
    112|       expect(context.b).toBe(context.nested.a_.a__);
       |                         ^
    113|     }));
    114|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:104:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[5/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a derived effect containing a function which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:134:25
    132|       applyEffect("b := id(a)", context, setContext);
    133|       setContext("a", 2);
    134|       expect(context.b).toBe(context.a);
       |                         ^
    135|     }));
    136|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:130:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[6/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a somewhat complex effect which updates from its dependency
AssertionError: expected 3 to be 4 // Object.is equality

- Expected
+ Received

- 4
+ 3

 ❯ src/effects/index.test.ts:150:25
    148|       );
    149|       setContext("nested", "a", 2);
    150|       expect(context.d).toBe(4);
       |                         ^
    151|     }));
    152|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:138:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[7/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a somewhat complex effect on a nested target which updates from its dependency
AssertionError: expected 3 to be 4 // Object.is equality

- Expected
+ Received

- 4
+ 3

 ❯ src/effects/index.test.ts:167:32
    165|       );
    166|       setContext("nested", "a", 2);
    167|       expect(context.effect.d).toBe(4);
       |                                ^
    168|     }));
    169|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:154:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[8/9]⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a nested derived effect on a sibling target which updates from its dependency
AssertionError: expected 1 to be 2 // Object.is equality

- Expected
+ Received

- 2
+ 1

 ❯ src/effects/index.test.ts:179:32
    177|       applyEffect("nested.d := nested.a", context, setContext);
    178|       setContext("nested", "a", 2);
    179|       expect(context.nested.d).toBe(context.nested.a);
       |                                ^
    180|     }));
    181|
 ❯ src/effects/index.test.ts:11:7
 ❯ Module.createRoot node_modules/solid-js/dist/server.js:53:14
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:171:5

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[9/9]⎯

 Test Files  1 failed | 1 passed (2)
      Tests  9 failed | 18 passed | 1 skipped (28)
   Start at  12:06:33
   Duration  506ms (transform 91ms, setup 0ms, collect 193ms, tests 20ms, environment 414ms, prepare 111ms)

Use asynchronous SQL queries via `aiosqlite`

This way, we can expose asynchronous FastAPI endpoints, which is natively handled by uvicorn (the blessed [ASGI](https://asgi.readthedocs.io/en/latest/ server to run FastAPI apps).

Move i18n to the frontend

Only install production JS dependencies in the docker image

We don't need dev dependencies to be installed in the image, as it will only contain the compiled js.

Implement a Server-Sent Event endpoint so that multiple screens can get updated at the same time

By implementing an SSE endpoint, we could propagate an update on multiple screens looking at the same resource pretty much immediately.

Replace `fastapi-auth-jwt` by `fastapi-jwt`, as the first is unmaintained

fastapi-auth-jwt is unmaintained, and collides with pydantic>=2.0.0.

Allow text fields to contain markdown

`npm run test` fails to run `src/effects/index.test.ts`

Running npm run test fails to run the tests defined in src/effects/index.test.ts:

$ npm run test
> test
> vitest --run


 RUN  v0.32.4 /Users/br/code/5esheets/dnd5esheets/front

 ✓ src/effects/parser/index.test.ts (10)
 ❯ src/effects/index.test.ts (18)
   ❯ apply effect (18)
     × applies a static effect
     × applies a derived effect
     × applies a derived effect which updates from its dependency
     × applies a nested derived effect
     × applies a nested derived effect which updates from its dependency
     × applies a deeply nested derived effect
     × applies a nested derived effect which updates from its dependency
     × applies a non-computed nested derived effect
     × applies a non-computed nested derived effect which updates from its dependency
     × applies a non-computed deeply nested derived effect
     × applies a non-computed deeply nested derived effect which updates from its dependency
     × applies an effect containing a function
     × applies a derived effect containing a function
     × applies a derived effect containing a function which updates from its dependency
     × applies a somewhat complex effect which updates from its dependency
     × applies a somewhat complex effect on a nested target which updates from its dependency
     × applies a nested derived effect on a sibling target which updates from its dependency
     ↓ applies a derived effect containing a function which updates from its dependency [skipped]

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ Failed Tests 17 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

 FAIL  src/effects/index.test.ts > apply effect > applies a static effect
TypeError: Cannot read properties of undefined (reading 'registerGraph')
 ❯ Module.createStore node_modules/solid-js/store/dist/dev.js:213:9

 ❯ src/effects/index.test.ts:21:37
 ❯ src/effects/index.test.ts:11:7
 ❯ updateFn node_modules/solid-js/dist/dev.js:180:17
 ❯ runUpdates node_modules/solid-js/dist/dev.js:800:17
 ❯ Module.createRoot node_modules/solid-js/dist/dev.js:185:12
 ❯ src/effects/index.test.ts:10:5
 ❯ inRoot src/effects/index.test.ts:9:9
 ❯ src/effects/index.test.ts:20:5
...

However the tests are run when defining NODE_ENV=prod.

Implement REST API handlers for each model

This will allow us to communicate between Svelte and the backend, delegating data rendering and update to the JS code.

Spec out an effect system

The goal here is to come up with a proof of concept or a spec of a system that would allow users to define effects, whether they would apply on items, spells equipment or something else, and have that effect be evaluated at runtime.

For example, we could define an armour with an effect of add +3 to your AC, and how the AC is calculated, its score, etc, will all be dynamically evaluated.

Let's figure out the syntax of that system, and its limits

Clean up CSS

The CSS I started with was a compiled version of a SASS codebase. I could remove a lot of useless style by adding some components (score block, rounded box, etc).