isolated constructor functions for entities and relations from config

app/src/data/AppData.ts

@@ -1,52 +1,20 @@
 import { transformObject } from "core/utils";
-import { DataPermissions, Entity, EntityIndex, type EntityManager, type Field } from "data";
+import {
+   DataPermissions,
+   type Entity,
+   EntityIndex,
+   type EntityManager,
+   constructEntity,
+   constructRelation
+} from "data";
 import { Module } from "modules/Module";
 import { DataController } from "./api/DataController";
-import {
-   type AppDataConfig,
-   FIELDS,
-   RELATIONS,
-   type TAppDataEntity,
-   type TAppDataRelation,
-   dataConfigSchema
-} from "./data-schema";
+import { type AppDataConfig, dataConfigSchema } from "./data-schema";
 
 export class AppData<DB> extends Module<typeof dataConfigSchema> {
-   static constructEntity(name: string, entityConfig: TAppDataEntity) {
-      const fields = transformObject(entityConfig.fields ?? {}, (fieldConfig, name) => {
-         const { type } = fieldConfig;
-         if (!(type in FIELDS)) {
-            throw new Error(`Field type "${type}" not found`);
-         }
-
-         const { field } = FIELDS[type as any];
-         const returnal = new field(name, fieldConfig.config) as Field;
-         return returnal;
-      });
-
-      // @todo: entity must be migrated to typebox
-      return new Entity(
-         name,
-         Object.values(fields),
-         entityConfig.config as any,
-         entityConfig.type as any
-      );
-   }
-
-   static constructRelation(
-      relationConfig: TAppDataRelation,
-      resolver: (name: Entity | string) => Entity
-   ) {
-      return new RELATIONS[relationConfig.type].cls(
-         resolver(relationConfig.source),
-         resolver(relationConfig.target),
-         relationConfig.config
-      );
-   }
-
    override async build() {
       const entities = transformObject(this.config.entities ?? {}, (entityConfig, name) => {
-         return AppData.constructEntity(name, entityConfig);
+         return constructEntity(name, entityConfig);
       });
 
       const _entity = (_e: Entity | string): Entity => {
@@ -57,7 +25,7 @@ export class AppData<DB> extends Module<typeof dataConfigSchema> {
       };
 
       const relations = transformObject(this.config.relations ?? {}, (relation) =>
-         AppData.constructRelation(relation, _entity)
+         constructRelation(relation, _entity)
       );
 
       const indices = transformObject(this.config.indices ?? {}, (index, name) => {

app/src/data/index.ts

@@ -18,6 +18,8 @@ export { LibsqlConnection, type LibSqlCredentials } from "./connection/LibsqlCon
 export { SqliteConnection } from "./connection/SqliteConnection";
 export { SqliteLocalConnection } from "./connection/SqliteLocalConnection";
 
+export { constructEntity, constructRelation } from "./schema/constructor";
+
 export const DatabaseEvents = {
    ...MutatorEvents,
    ...RepositoryEvents

app/src/data/schema/constructor.ts

@@ -0,0 +1,34 @@
+import { transformObject } from "core/utils";
+import { Entity, type Field } from "data";
+import { FIELDS, RELATIONS, type TAppDataEntity, type TAppDataRelation } from "data/data-schema";
+
+export function constructEntity(name: string, entityConfig: TAppDataEntity) {
+   const fields = transformObject(entityConfig.fields ?? {}, (fieldConfig, name) => {
+      const { type } = fieldConfig;
+      if (!(type in FIELDS)) {
+         throw new Error(`Field type "${type}" not found`);
+      }
+
+      const { field } = FIELDS[type as any];
+      const returnal = new field(name, fieldConfig.config) as Field;
+      return returnal;
+   });
+
+   return new Entity(
+      name,
+      Object.values(fields),
+      entityConfig.config as any,
+      entityConfig.type as any
+   );
+}
+
+export function constructRelation(
+   relationConfig: TAppDataRelation,
+   resolver: (name: Entity | string) => Entity
+) {
+   return new RELATIONS[relationConfig.type].cls(
+      resolver(relationConfig.source),
+      resolver(relationConfig.target),
+      relationConfig.config
+   );
+}

app/src/ui/client/api/use-data.ts

@@ -10,7 +10,7 @@ type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => any
  * the first argument "entity" for convenience
  * @param entity
  */
-export const useData = <T extends keyof DataApi>(entity: string) => {
+export const useData = <T extends keyof DataApi<DB>>(entity: string) => {
    const api = useApi().data;
    const methods = [
       "readOne",

app/src/ui/client/schema/data/use-bknd-data.ts

@@ -1,6 +1,5 @@
 import { Type, TypeInvalidError, parse, transformObject } from "core/utils";
-import type { Entity } from "data";
-import { AppData } from "data/AppData";
+import { constructEntity } from "data";
 import {
    type TAppDataEntity,
    type TAppDataEntityFields,
@@ -19,7 +18,7 @@ export function useBkndData() {
 
    // @todo: potentially store in ref, so it doesn't get recomputed? or use memo?
    const entities = transformObject(config.data.entities ?? {}, (entity, name) => {
-      return AppData.constructEntity(name, entity);
+      return constructEntity(name, entity);
    });
 
    const actions = {

app/src/ui/client/utils/AppReduced.ts

@@ -1,6 +1,5 @@
 import type { App } from "App";
-import type { Entity, EntityRelation } from "data";
-import { AppData } from "data/AppData";
+import { type Entity, type EntityRelation, constructEntity, constructRelation } from "data";
 import { RelationAccessor } from "data/relations/RelationAccessor";
 import { Flow, TaskMap } from "flows";
 
@@ -20,11 +19,11 @@ export class AppReduced {
       //console.log("received appjson", appJson);
 
       this._entities = Object.entries(this.appJson.data.entities ?? {}).map(([name, entity]) => {
-         return AppData.constructEntity(name, entity);
+         return constructEntity(name, entity);
       });
 
       this._relations = Object.entries(this.appJson.data.relations ?? {}).map(([, relation]) => {
-         return AppData.constructRelation(relation, this.entity.bind(this));
+         return constructRelation(relation, this.entity.bind(this));
       });
 
       for (const [name, obj] of Object.entries(this.appJson.flows.flows ?? {})) {