optimized module manager seeding, added type support for new api hooks and reduced amount of dist chunks

2026-03-16 20:37:21 +00:00 · 2024-12-18 18:22:01 +01:00
parent c4138ef823
commit 602235b372
41 changed files with 434 additions and 328 deletions
--- a/app/src/data/api/DataApi.ts
+++ b/app/src/data/api/DataApi.ts
@@ -5,7 +5,7 @@ export type DataApiOptions = BaseModuleApiOptions & {
   defaultQuery?: Partial<RepoQuery>;
 };

-export class DataApi extends ModuleApi<DataApiOptions> {
+export class DataApi<DB> extends ModuleApi<DataApiOptions> {
   protected override getDefaultOptions(): Partial<DataApiOptions> {
      return {
         basepath: "/api/data",
@@ -15,48 +15,60 @@ export class DataApi extends ModuleApi<DataApiOptions> {
      };
   }

-   readOne(
-      entity: string,
+   readOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
+      entity: E,
      id: PrimaryFieldType,
      query: Partial<Omit<RepoQuery, "where" | "limit" | "offset">> = {}
   ) {
-      return this.get<RepositoryResponse<EntityData>>([entity, id], query);
+      return this.get<Pick<RepositoryResponse<Data>, "meta" | "data">>([entity as any, id], query);
   }

-   readMany(entity: string, query: Partial<RepoQuery> = {}) {
-      return this.get<Pick<RepositoryResponse, "meta" | "data">>(
-         [entity],
-         query ?? this.options.defaultQuery
-      );
-   }
-
-   readManyByReference(
-      entity: string,
-      id: PrimaryFieldType,
-      reference: string,
+   readMany<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
+      entity: E,
      query: Partial<RepoQuery> = {}
   ) {
-      return this.get<Pick<RepositoryResponse, "meta" | "data">>(
-         [entity, id, reference],
+      return this.get<Pick<RepositoryResponse<Data[]>, "meta" | "data">>(
+         [entity as any],
         query ?? this.options.defaultQuery
      );
   }

-   createOne(entity: string, input: EntityData) {
-      return this.post<RepositoryResponse<EntityData>>([entity], input);
+   readManyByReference<
+      E extends keyof DB | string,
+      R extends keyof DB | string,
+      Data = R extends keyof DB ? DB[R] : EntityData
+   >(entity: E, id: PrimaryFieldType, reference: R, query: Partial<RepoQuery> = {}) {
+      return this.get<Pick<RepositoryResponse<Data[]>, "meta" | "data">>(
+         [entity as any, id, reference],
+         query ?? this.options.defaultQuery
+      );
   }

-   updateOne(entity: string, id: PrimaryFieldType, input: EntityData) {
-      return this.patch<RepositoryResponse<EntityData>>([entity, id], input);
+   createOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
+      entity: E,
+      input: Data
+   ) {
+      return this.post<RepositoryResponse<Data>>([entity as any], input);
   }

-   deleteOne(entity: string, id: PrimaryFieldType) {
-      return this.delete<RepositoryResponse<EntityData>>([entity, id]);
+   updateOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
+      entity: E,
+      id: PrimaryFieldType,
+      input: Partial<Data>
+   ) {
+      return this.patch<RepositoryResponse<Data>>([entity as any, id], input);
   }

-   count(entity: string, where: RepoQuery["where"] = {}) {
-      return this.post<RepositoryResponse<{ entity: string; count: number }>>(
-         [entity, "fn", "count"],
+   deleteOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
+      entity: E,
+      id: PrimaryFieldType
+   ) {
+      return this.delete<RepositoryResponse<Data>>([entity as any, id]);
+   }
+
+   count<E extends keyof DB | string>(entity: E, where: RepoQuery["where"] = {}) {
+      return this.post<RepositoryResponse<{ entity: E; count: number }>>(
+         [entity as any, "fn", "count"],
         where
      );
   }
--- a/app/src/data/api/DataController.ts
+++ b/app/src/data/api/DataController.ts
@@ -165,13 +165,12 @@ export class DataController implements ClassController {
         // read entity schema
         .get("/schema.json", async (c) => {
            this.guard.throwUnlessGranted(DataPermissions.entityRead);
-            const url = new URL(c.req.url);
-            const $id = `${url.origin}${this.config.basepath}/schema.json`;
+            const $id = `${this.config.basepath}/schema.json`;
            const schemas = Object.fromEntries(
               this.em.entities.map((e) => [
                  e.name,
                  {
-                     $ref: `schemas/${e.name}`
+                     $ref: `${this.config.basepath}/schemas/${e.name}`
                  }
               ])
            );
@@ -198,7 +197,7 @@ export class DataController implements ClassController {
               const schema = _entity.toSchema();
               const url = new URL(c.req.url);
               const base = `${url.origin}${this.config.basepath}`;
-               const $id = `${base}/schemas/${entity}`;
+               const $id = `${this.config.basepath}/schemas/${entity}`;
               return c.json({
                  $schema: `${base}/schema.json`,
                  $id,
--- a/app/src/data/entities/EntityManager.ts
+++ b/app/src/data/entities/EntityManager.ts
@@ -14,6 +14,14 @@ import { SchemaManager } from "../schema/SchemaManager";
 import { Entity } from "./Entity";
 import { type EntityData, Mutator, Repository } from "./index";

+type EntitySchema<E extends Entity | string, DB = any> = E extends Entity<infer Name>
+   ? Name extends keyof DB
+      ? Name
+      : never
+   : E extends keyof DB
+     ? E
+     : never;
+
 export class EntityManager<DB> {
   connection: Connection;

@@ -87,10 +95,16 @@ export class EntityManager<DB> {
      this.entities.push(entity);
   }

-   entity(name: string): Entity {
-      const entity = this.entities.find((e) => e.name === name);
+   entity(e: Entity | string): Entity {
+      let entity: Entity | undefined;
+      if (typeof e === "string") {
+         entity = this.entities.find((entity) => entity.name === e);
+      } else {
+         entity = e;
+      }
+
      if (!entity) {
-         throw new EntityNotDefinedException(name);
+         throw new EntityNotDefinedException(typeof e === "string" ? e : e.name);
      }

      return entity;
@@ -162,28 +176,16 @@ export class EntityManager<DB> {
      return this.relations.relationReferencesOf(this.entity(entity_name));
   }

-   repository(_entity: Entity | string) {
-      const entity = _entity instanceof Entity ? _entity : this.entity(_entity);
-      return new Repository(this, entity, this.emgr);
+   repository<E extends Entity | string>(entity: E): Repository<DB, EntitySchema<E, DB>> {
+      return this.repo(entity);
   }

-   repo<E extends Entity>(
-      _entity: E
-   ): Repository<
-      DB,
-      E extends Entity<infer Name> ? (Name extends keyof DB ? Name : never) : never
-   > {
-      return new Repository(this, _entity, this.emgr);
+   repo<E extends Entity | string>(entity: E): Repository<DB, EntitySchema<E, DB>> {
+      return new Repository(this, this.entity(entity), this.emgr);
   }

-   _repo<TB extends keyof DB>(_entity: TB): Repository<DB, TB> {
-      const entity = this.entity(_entity as any);
-      return new Repository(this, entity, this.emgr);
-   }
-
-   mutator(_entity: Entity | string) {
-      const entity = _entity instanceof Entity ? _entity : this.entity(_entity);
-      return new Mutator(this, entity, this.emgr);
+   mutator<E extends Entity | string>(entity: E): Mutator<DB, EntitySchema<E, DB>> {
+      return new Mutator(this, this.entity(entity), this.emgr);
   }

   addIndex(index: EntityIndex, force = false) {
--- a/app/src/data/entities/Mutator.ts
+++ b/app/src/data/entities/Mutator.ts
@@ -25,7 +25,9 @@ export type MutatorResponse<T = EntityData[]> = {
   data: T;
 };

-export class Mutator<DB> implements EmitsEvents {
+export class Mutator<DB = any, TB extends keyof DB = any, Data = Omit<DB[TB], "id">>
+   implements EmitsEvents
+{
   em: EntityManager<DB>;
   entity: Entity;
   static readonly Events = MutatorEvents;
@@ -47,13 +49,13 @@ export class Mutator<DB> implements EmitsEvents {
      return this.em.connection.kysely;
   }

-   async getValidatedData(data: EntityData, context: TActionContext): Promise<EntityData> {
+   async getValidatedData<Given = any>(data: Given, context: TActionContext): Promise<Given> {
      const entity = this.entity;
      if (!context) {
         throw new Error("Context must be provided for validation");
      }

-      const keys = Object.keys(data);
+      const keys = Object.keys(data as any);
      const validatedData: EntityData = {};

      // get relational references/keys
@@ -95,7 +97,7 @@ export class Mutator<DB> implements EmitsEvents {
         throw new Error(`No data left to update "${entity.name}"`);
      }

-      return validatedData;
+      return validatedData as Given;
   }

   protected async many(qb: MutatorQB): Promise<MutatorResponse> {
@@ -120,7 +122,7 @@ export class Mutator<DB> implements EmitsEvents {
      return { ...response, data: data[0]! };
   }

-   async insertOne(data: EntityData): Promise<MutatorResponse<EntityData>> {
+   async insertOne(data: Data): Promise<MutatorResponse<DB[TB]>> {
      const entity = this.entity;
      if (entity.type === "system" && this.__unstable_disable_system_entity_creation) {
         throw new Error(`Creation of system entity "${entity.name}" is disabled`);
@@ -154,10 +156,10 @@ export class Mutator<DB> implements EmitsEvents {

      await this.emgr.emit(new Mutator.Events.MutatorInsertAfter({ entity, data: res.data }));

-      return res;
+      return res as any;
   }

-   async updateOne(id: PrimaryFieldType, data: EntityData): Promise<MutatorResponse<EntityData>> {
+   async updateOne(id: PrimaryFieldType, data: Data): Promise<MutatorResponse<DB[TB]>> {
      const entity = this.entity;
      if (!Number.isInteger(id)) {
         throw new Error("ID must be provided for update");
@@ -166,12 +168,16 @@ export class Mutator<DB> implements EmitsEvents {
      const validatedData = await this.getValidatedData(data, "update");

      await this.emgr.emit(
-         new Mutator.Events.MutatorUpdateBefore({ entity, entityId: id, data: validatedData })
+         new Mutator.Events.MutatorUpdateBefore({
+            entity,
+            entityId: id,
+            data: validatedData as any
+         })
      );

      const query = this.conn
         .updateTable(entity.name)
-         .set(validatedData)
+         .set(validatedData as any)
         .where(entity.id().name, "=", id)
         .returning(entity.getSelect());

@@ -181,10 +187,10 @@ export class Mutator<DB> implements EmitsEvents {
         new Mutator.Events.MutatorUpdateAfter({ entity, entityId: id, data: res.data })
      );

-      return res;
+      return res as any;
   }

-   async deleteOne(id: PrimaryFieldType): Promise<MutatorResponse<EntityData>> {
+   async deleteOne(id: PrimaryFieldType): Promise<MutatorResponse<DB[TB]>> {
      const entity = this.entity;
      if (!Number.isInteger(id)) {
         throw new Error("ID must be provided for deletion");
@@ -203,7 +209,7 @@ export class Mutator<DB> implements EmitsEvents {
         new Mutator.Events.MutatorDeleteAfter({ entity, entityId: id, data: res.data })
      );

-      return res;
+      return res as any;
   }

   private getValidOptions(options?: Partial<RepoQuery>): Partial<RepoQuery> {
@@ -250,47 +256,24 @@ export class Mutator<DB> implements EmitsEvents {
   }

   // @todo: decide whether entries should be deleted all at once or one by one (for events)
-   async deleteWhere(where?: RepoQuery["where"]): Promise<MutatorResponse<EntityData>> {
+   async deleteWhere(where?: RepoQuery["where"]): Promise<MutatorResponse<DB[TB][]>> {
      const entity = this.entity;

      const qb = this.appendWhere(this.conn.deleteFrom(entity.name), where).returning(
         entity.getSelect()
      );

-      //await this.emgr.emit(new Mutator.Events.MutatorDeleteBefore({ entity, entityId: id }));
-
-      const res = await this.many(qb);
-
-      /*await this.emgr.emit(
-         new Mutator.Events.MutatorDeleteAfter({ entity, entityId: id, data: res.data })
-      );*/
-
-      return res;
+      return (await this.many(qb)) as any;
   }

-   async updateWhere(
-      data: EntityData,
-      where?: RepoQuery["where"]
-   ): Promise<MutatorResponse<EntityData>> {
+   async updateWhere(data: Data, where?: RepoQuery["where"]): Promise<MutatorResponse<DB[TB][]>> {
      const entity = this.entity;
-
      const validatedData = await this.getValidatedData(data, "update");

-      /*await this.emgr.emit(
-         new Mutator.Events.MutatorUpdateBefore({ entity, entityId: id, data: validatedData })
-      );*/
-
      const query = this.appendWhere(this.conn.updateTable(entity.name), where)
-         .set(validatedData)
-         //.where(entity.id().name, "=", id)
+         .set(validatedData as any)
         .returning(entity.getSelect());

-      const res = await this.many(query);
-
-      /*await this.emgr.emit(
-         new Mutator.Events.MutatorUpdateAfter({ entity, entityId: id, data: res.data })
-      );*/
-
-      return res;
+      return (await this.many(query)) as any;
   }
 }
--- a/app/src/data/entities/query/Repository.ts
+++ b/app/src/data/entities/query/Repository.ts
@@ -272,7 +272,7 @@ export class Repository<DB = any, TB extends keyof DB = any> implements EmitsEve
   async findId(
      id: PrimaryFieldType,
      _options?: Partial<Omit<RepoQuery, "where" | "limit" | "offset">>
-   ): Promise<RepositoryResponse<DB[TB]>> {
+   ): Promise<RepositoryResponse<DB[TB] | undefined>> {
      const { qb, options } = this.buildQuery(
         {
            ..._options,
--- a/app/src/data/prototype/index.ts
+++ b/app/src/data/prototype/index.ts
@@ -1,3 +1,5 @@
+import type { Generated } from "kysely";
+import { MediaField, type MediaFieldConfig, type MediaItem } from "media/MediaField";
 import {
   BooleanField,
   type BooleanFieldConfig,
@@ -25,15 +27,14 @@ import {
   type TEntityType,
   TextField,
   type TextFieldConfig
-} from "data";
-import type { Generated } from "kysely";
-import { MediaField, type MediaFieldConfig, type MediaItem } from "media/MediaField";
+} from "../index";

 type Options<Config = any> = {
   entity: { name: string; fields: Record<string, Field<any, any, any>> };
   field_name: string;
   config: Config;
   is_required: boolean;
+   another?: string;
 };

 const FieldMap = {
@@ -239,7 +240,7 @@ export function relation<Local extends Entity>(local: Local) {
   };
 }

-type InferEntityFields<T> = T extends Entity<infer _N, infer Fields>
+export type InferEntityFields<T> = T extends Entity<infer _N, infer Fields>
   ? {
        [K in keyof Fields]: Fields[K] extends { _type: infer Type; _required: infer Required }
           ? Required extends true
@@ -284,12 +285,25 @@ type OptionalUndefined<
   }
 >;

-type InferField<Field> = Field extends { _type: infer Type; _required: infer Required }
+export type InferField<Field> = Field extends { _type: infer Type; _required: infer Required }
   ? Required extends true
      ? Type
      : Type | undefined
   : never;

+const n = number();
+type T2 = InferField<typeof n>;
+
+const users = entity("users", {
+   name: text(),
+   email: text(),
+   created_at: datetime(),
+   updated_at: datetime()
+});
+type TUsersFields = InferEntityFields<typeof users>;
+type TUsers = Schema<typeof users>;
+type TUsers2 = Simplify<OptionalUndefined<Schema<typeof users>>>;
+
 export type InsertSchema<T> = Simplify<OptionalUndefined<InferEntityFields<T>>>;
-export type Schema<T> = { id: Generated<number> } & InsertSchema<T>;
+export type Schema<T> = Simplify<{ id: Generated<number> } & InsertSchema<T>>;
 export type FieldSchema<T> = Simplify<OptionalUndefined<InferFields<T>>>;