@tiddlywiki/mws 0.0.12 → 0.0.14

package/src/routes/managers/manager-recipes.ts

@@ -1,438 +0,0 @@
-import { registerZodRoutes, SiteConfig, zodManage, RouterKeyMap, RouterRouteMap } from "../router";
-import { DataChecks } from "../../utils";
-import { AuthUser } from "../services/sessions";
-
-// https://crates.io/crates/indradb
-
-
-export const RecipeKeyMap: RouterKeyMap<RecipeManager, true> = {
-  index_json: true,
-
-  bag_create: true,
-  bag_update: true,
-  bag_upsert: true,
-  bag_delete: true,
-  bag_acl_update: true,
-
-  recipe_create: true,
-  recipe_update: true,
-  recipe_upsert: true,
-  recipe_delete: true,
-  recipe_acl_update: true,
-
-}
-
-export type RecipeManagerMap = RouterRouteMap<RecipeManager>;
-
-export class RecipeManager {
-
-  static defineRoutes(root: rootRoute, config: SiteConfig) {
-    registerZodRoutes(root, new RecipeManager(config), Object.keys(RecipeKeyMap));
-  }
-
-  checks: DataChecks;
-
-  constructor(private config: SiteConfig) {
-    const { allowAnonReads, allowAnonWrites } = config;
-    this.checks = new DataChecks({ allowAnonReads, allowAnonWrites })
-  }
-
-  index_json = zodManage(z => z.undefined(), async (state, prisma) => {
-
-    const { isAdmin, user_id, username, role_ids } = state.user;
-
-    const OR = this.checks.getBagWhereACL({ permission: "READ", user_id, role_ids });
-
-    const bagList = await prisma.bags.findMany({
-      include: {
-        _count: isAdmin ? undefined : {
-          select: {
-            acl: {
-              where: {
-                permission: "ADMIN",
-                role_id: { in: role_ids }
-              }
-            }
-          }
-        },
-        acl: true,
-      },
-      where: isAdmin ? undefined : { OR }
-    });
-
-    const recipeList = await prisma.recipes.findMany({
-      include: {
-        recipe_bags: {
-          select: { bag_id: true, position: true, with_acl: true, },
-          orderBy: { position: "asc" }
-        },
-        acl: true,
-        _count: isAdmin ? undefined : {
-          select: {
-            acl: {
-              where: {
-                permission: "ADMIN",
-                role_id: { in: role_ids }
-              }
-            }
-          }
-        },
-      },
-      where: isAdmin ? undefined : { recipe_bags: { every: { bag: { OR } } } }
-    });
-
-    const userListUser = !isAdmin && await prisma.users.findMany({
-      select: { user_id: true, username: true }
-    });
-
-    const userListAdmin = !!isAdmin && await prisma.users.findMany({
-      select: { user_id: true, username: true, email: true, roles: true, last_login: true, created_at: true }
-    });
-
-    const roleList = await prisma.roles.findMany();
-
-    return {
-      bagList,
-      recipeList,
-      isAdmin,
-      user_id,
-      userListUser,
-      userListAdmin,
-      roleList,
-      username,
-      isLoggedIn: state.user.isLoggedIn,
-      allowAnonReads: state.config.allowAnonReads,
-      allowAnonWrites: state.config.allowAnonWrites,
-    }
-  });
-
-  recipe_create = zodManage(z => z.object({
-    recipe_name: z.string(),
-    description: z.string(),
-    bag_names: z.array(z.object({ bag_name: z.string(), with_acl: z.boolean() })),
-    owner_id: z.prismaField("Recipes", "owner_id", "number", true).optional(),
-    isCreate: z.literal(true).default(true),
-  }), async (state, prisma) => {
-    return await this.recipeCreateOrUpdate(state.data, prisma, state.user);
-  });
-  recipe_update = zodManage(z => z.object({
-    recipe_name: z.string(),
-    description: z.string(),
-    bag_names: z.array(z.object({ bag_name: z.string(), with_acl: z.boolean() })),
-    owner_id: z.prismaField("Recipes", "owner_id", "number", true).optional(),
-    isCreate: z.literal(false).default(false),
-  }), async (state, prisma) => {
-    return await this.recipeCreateOrUpdate(state.data, prisma, state.user);
-  });
-
-  recipe_upsert = zodManage(z => z.object({
-    recipe_name: z.string(),
-    description: z.string(),
-    bag_names: z.array(z.object({ bag_name: z.string(), with_acl: z.boolean() })),
-    owner_id: z.prismaField("Recipes", "owner_id", "number", true).optional(),
-    isCreate: z.boolean(),
-  }), async (state, prisma) => {
-    return await this.recipeCreateOrUpdate(state.data, prisma, state.user);
-  });
-
-  bag_create = zodManage(z => z.object({
-    bag_name: z.string(),
-    description: z.string(),
-    is_plugin: z.boolean(),
-    owner_id: z.prismaField("Bags", "owner_id", "number", true).optional(),
-    isCreate: z.literal(true).default(true),
-  }), async (state, prisma) => {
-    return await this.bagCreateOrUpdate(state.data, prisma, state.user);
-  });
-
-  bag_update = zodManage(z => z.object({
-    bag_name: z.string(),
-    description: z.string(),
-    is_plugin: z.boolean(),
-    owner_id: z.prismaField("Bags", "owner_id", "number", true).optional(),
-    isCreate: z.literal(false).default(false),
-  }), async (state, prisma) => {
-    return await this.bagCreateOrUpdate(state.data, prisma, state.user);
-  });
-
-  bag_upsert = zodManage(z => z.object({
-    bag_name: z.string(),
-    description: z.string(),
-    is_plugin: z.boolean(),
-    owner_id: z.prismaField("Bags", "owner_id", "number", true).optional(),
-    isCreate: z.boolean(),
-  }), async (state, prisma) => {
-    return await this.bagCreateOrUpdate(state.data, prisma, state.user);
-  });
-
-  async recipeCreateOrUpdate({ bag_names, description, owner_id, recipe_name, isCreate }: {
-    recipe_name: string,
-    description: string,
-    bag_names: { bag_name: string, with_acl: boolean }[],
-    owner_id?: number | null,
-    isCreate: boolean,
-  }, prisma: PrismaTxnClient, user: AuthUser) {
-    const existing = await prisma.recipes.findUnique({ where: { recipe_name }, });
-
-    this.assertCreateOrUpdate({ user, type: "recipe", isCreate, owner_id, existing, });
-
-    const { isAdmin, user_id } = user;
-
-    const OR = this.checks.getWhereACL({ permission: "ADMIN", user_id, });
-
-    const bags = new Map(
-      await prisma.bags.findMany({
-        where: { bag_name: { in: bag_names.map(e => e.bag_name) } },
-      }).then(bags => bags.map(bag => [bag.bag_name as string, bag]))
-    );
-
-    const missing = bag_names.filter(e => !bags.has(e.bag_name));
-    if (missing.length) throw "Some bags not found: " + JSON.stringify(missing);
-
-    const bagsAcl = new Map(
-      await prisma.bags.findMany({
-        where: { bag_name: { in: bag_names.map(e => e.bag_name) }, OR },
-      }).then(bags => bags.map(bag => [bag.bag_name as string, bag]))
-    );
-
-    const createBags = bag_names.map((bag, position) => ({
-      bag_id: bags.get(bag.bag_name)!.bag_id,
-      with_acl: bagsAcl && bagsAcl.has(bag.bag_name) && bag.with_acl,
-      position,
-    }));
-
-    if (existing) {
-      await prisma.recipes.update({
-        where: { recipe_name },
-        data: {
-          description,
-          owner_id: isAdmin ? owner_id : undefined,
-          recipe_bags: {
-            deleteMany: {},
-          }
-        }
-      });
-      await prisma.recipes.update({
-        where: { recipe_name },
-        data: {
-          recipe_bags: {
-            create: createBags
-          }
-        }
-      });
-      return existing;
-    } else {
-
-      return await prisma.recipes.create({
-        data: {
-          recipe_name,
-          description,
-          recipe_bags: { create: createBags },
-          owner_id: isAdmin ? owner_id : user_id
-        },
-      });
-    }
-  }
-
-  async bagCreateOrUpdate({ bag_name, description, is_plugin, owner_id, isCreate }: {
-    bag_name: string,
-    description: string,
-    is_plugin: boolean,
-    owner_id?: number | null,
-    isCreate: boolean,
-  }, prisma: PrismaTxnClient, user: AuthUser) {
-    const existing = await prisma.bags.findUnique({
-      where: { bag_name },
-      select: { owner_id: true }
-    });
-
-    this.assertCreateOrUpdate({ type: "bag", isCreate, owner_id, existing, user });
-
-    const { isAdmin, user_id } = user;
-
-    return await prisma.bags.upsert({
-      where: { bag_name },
-      update: {
-        description,
-        is_plugin,
-        owner_id: isAdmin ? owner_id : undefined //undefined leaves the value as-is
-      },
-      create: {
-        bag_name,
-        description,
-        is_plugin,
-        owner_id: isAdmin ? owner_id : user_id
-      },
-    });
-
-  }
-
-
-  assertCreateOrUpdate({
-    existing, isCreate, owner_id, type, user
-  }: {
-    user: AuthUser,
-    isCreate: boolean,
-    owner_id?: number | null,
-    existing: { owner_id: PrismaField<"Users", "user_id"> | null } | null
-    type: "recipe" | "bag"
-  }) {
-    // check user_id just to be safe because we depend on it for an additional check here and elsewhere
-    // user_id 0 is also not a valid user_id and only used for anonymous users
-    if (!user.isLoggedIn || !user.user_id)
-      throw "User not authenticated";
-
-    const { isAdmin, user_id } = user;
-
-    if (!isAdmin && owner_id !== undefined)
-      throw "owner_id is only valid for admins";
-
-    if (existing && isCreate)
-      throw `A ${type} with this name already exists`;
-
-    if (existing && !isAdmin && existing.owner_id !== user_id)
-      throw `User does not own the ${type} and is not an admin`;
-
-  }
-
-  recipe_delete = zodManage(z => z.object({
-    recipe_name: z.string(),
-  }), async (state, prisma) => {
-    const { recipe_name } = state.data;
-
-    if (!state.user.isLoggedIn) throw "User not authenticated";
-
-    const recipe = await prisma.recipes.findUnique({
-      where: { recipe_name },
-    });
-
-    if (!recipe) throw "Recipe not found";
-
-    const { isAdmin, user_id } = state.user;
-
-    if (!isAdmin && recipe.owner_id !== user_id)
-      throw "User does not own the recipe and is not an admin";
-
-    await prisma.recipes.delete({
-      where: { recipe_name }
-    });
-
-    return null;
-  });
-
-  bag_delete = zodManage(z => z.object({
-    bag_name: z.string(),
-  }), async (state, prisma) => {
-    const { bag_name } = state.data;
-
-    if (!state.user.isLoggedIn) throw "User not authenticated";
-
-    const bag = await prisma.bags.findUnique({
-      where: { bag_name },
-      include: { _count: { select: { tiddlers: true } } }
-    });
-
-    if (!bag) throw "Bag not found";
-
-    const { isAdmin, user_id } = state.user;
-
-    if (!isAdmin && bag.owner_id !== user_id)
-      throw "User does not own the bag and is not an admin";
-
-    if (bag._count.tiddlers)
-      throw "Bag has tiddlers added and can no longer be deleted.";
-
-    await prisma.bags.delete({
-      where: { bag_name }
-    });
-
-    return null;
-  });
-
-  //   Partial<{
-  //     role_id: number | null;
-  //     permission: "READ" | "WRITE" | "ADMIN";
-  // }>[]
-  recipe_acl_update = zodManage(z => z.object({
-    recipe_name: z.prismaField("Recipes", "recipe_name", "string"),
-    acl: z.array(z.object({
-      role_id: z.number().nullable(),
-      permission: z.enum(["READ", "WRITE", "ADMIN"]),
-    })),
-  }), async (state, prisma) => {
-    const { recipe_name, acl } = state.data;
-
-    if (!state.user.isLoggedIn) throw "User not authenticated";
-
-    const recipe = await prisma.recipes.findUnique({
-      where: { recipe_name }
-    });
-
-    if (!recipe) throw "Recipe not found";
-
-    const { isAdmin, user_id } = state.user;
-
-    if (!isAdmin && recipe.owner_id !== user_id)
-      throw "User does not own the recipe and is not an admin";
-
-    const distinct = new Set(acl.map(acl => JSON.stringify([acl.role_id, acl.permission])));
-
-    const { recipe_id } = recipe;
-
-    await prisma.recipeAcl.deleteMany({
-      where: { recipe_id }
-    });
-
-    await prisma.recipeAcl.createMany({
-      data: Array.from(distinct).map(e => {
-        const [role_id, permission] = JSON.parse(e);
-        return { recipe_id, role_id, permission };
-      })
-    });
-
-    return null;
-  });
-
-  bag_acl_update = zodManage(z => z.object({
-    bag_name: z.prismaField("Bags", "bag_name", "string"),
-    acl: z.array(z.object({
-      role_id: z.number().nullable(),
-      permission: z.enum(["READ", "WRITE", "ADMIN"]),
-    })),
-  }), async (state, prisma) => {
-    const { bag_name, acl } = state.data;
-
-    if (!state.user.isLoggedIn) throw "User not authenticated";
-
-    const bag = await prisma.bags.findUnique({
-      where: { bag_name },
-      include: { acl: true }
-    });
-
-    if (!bag) throw "Bag not found";
-
-    const { isAdmin, user_id } = state.user;
-
-    if (!isAdmin && bag.owner_id !== user_id)
-      throw "User does not own the bag and is not an admin";
-
-    const distinct = new Set(acl.map(acl => JSON.stringify([acl.role_id, acl.permission])));
-
-    const { bag_id } = bag;
-
-    await prisma.bagAcl.deleteMany({
-      where: { bag_id }
-    });
-
-    await prisma.bagAcl.createMany({
-      data: Array.from(distinct).map(e => {
-        const [role_id, permission] = JSON.parse(e);
-        return { bag_id, role_id, permission };
-      })
-    });
-
-    return null;
-  });
-
-
-}

package/src/routes/managers/manager-users.ts

@@ -1,201 +0,0 @@
-import { registerZodRoutes, SiteConfig, zodManage, RouterKeyMap, RouterRouteMap } from "../router";
-
-export const UserKeyMap: RouterKeyMap<UserManager, true> = {
-  user_edit_data: true,
-  user_create: true,
-  user_delete: true,
-  user_list: true,
-  user_update: true,
-  user_update_password: true,
-  role_create: true,
-  role_update: true,
-}
-
-export type UserManagerMap = RouterRouteMap<UserManager>;
-
-
-export class UserManager {
-  static defineRoutes(root: rootRoute, config: SiteConfig) {
-    registerZodRoutes(root, new UserManager(), Object.keys(UserKeyMap));
-  }
-
-  user_edit_data = zodManage(z => z.object({
-    user_id: z.prismaField("Users", "user_id", "number")
-  }), async (state, prisma) => {
-    state.okUser();
-    
-    const { user_id } = state.data;
-
-    if (!state.user.isAdmin && state.user.user_id !== user_id)
-      throw "Non-admins cannot retrieve the profile of other users"
-
-    const user = await prisma.users.findUnique({
-      where: { user_id },
-      select: {
-        user_id: true,
-        username: true,
-        email: true,
-        roles: true,
-        last_login: true,
-        created_at: true,
-      }
-    });
-    
-    if (!user) throw "User not found";
-    
-    const allRoles = await prisma.roles.findMany({
-      select: {
-        role_id: true,
-        role_name: true,
-        description: true,
-      }
-    });
-
-    return { user, allRoles }
-  });
-
-  user_list = zodManage(z => z.undefined(), async (state, prisma) => {
-
-    state.okAdmin();
-
-    const res = await prisma.users.findMany({
-      select: {
-        user_id: true,
-        username: true,
-        email: true,
-        roles: true,
-        last_login: true,
-        created_at: true,
-      }
-    });
-    return res.map(e => ({
-      ...e,
-      last_login: e.last_login?.toISOString(),
-      created_at: e.created_at.toISOString(),
-    }));
-  });
-
-
-  user_create = zodManage(z => z.object({
-    username: z.string(),
-    email: z.string(),
-    role_id: z.prismaField("Roles", "role_id", "number", false),
-  }), async (state, prisma) => {
-    const { username, email, role_id } = state.data;
-
-    state.okAdmin();
-
-    const user = await prisma.users.create({
-      data: { username, email, password: "", roles: { connect: { role_id } } },
-      select: { user_id: true, created_at: true }
-    });
-
-    return user;
-  });
-
-  user_update = zodManage(z => z.object({
-    user_id: z.number(),
-    username: z.string(),
-    email: z.string(),
-    role_id: z.prismaField("Roles", "role_id", "number").optional(),
-  }), async (state, prisma) => {
-    const { user_id, username, email, role_id } = state.data;
-
-    state.okAdmin();
-
-    if (state.user.user_id === user_id) throw "Admin cannot update themselves";
-
-    await prisma.users.update({
-      where: { user_id },
-      data: { username, email, roles: { set: [{ role_id }] } }
-    });
-
-    return null;
-  });
-
-
-  user_delete = zodManage(z => z.object({
-    user_id: z.number(),
-  }), async (state, prisma) => {
-    const { user_id } = state.data;
-
-    state.okAdmin();
-
-    if (state.user.user_id === user_id) throw "Admin cannot delete themselves";
-
-    const bags = await prisma.bags.count({ where: { owner_id: user_id } });
-
-    if (bags) throw "User owns bags and cannot be deleted";
-
-    await prisma.users.delete({ where: { user_id } });
-
-    return null;
-  });
-
-
-  user_update_password = zodManage(z => z.object({
-    user_id: z.prismaField("Users", "user_id", "number"),
-    registrationRequest: z.string().optional(),
-    registrationRecord: z.string().optional(),
-  }), async (state, prisma) => {
-    const { user_id, registrationRecord, registrationRequest } = state.data;
-
-    state.okUser();
-
-
-    if (state.user.user_id !== user_id && !state.user.isAdmin)
-      throw "You must be an admin to update another user's password";
-
-    const userExists = await prisma.users.count({ where: { user_id } });
-    if (!userExists) throw "User does not exist";
-
-    if (registrationRequest) {
-      return state.PasswordService.createRegistrationResponse({
-        userID: user_id,
-        registrationRequest
-      });
-    } else if (registrationRecord) {
-      await prisma.users.update({
-        where: { user_id },
-        data: { password: registrationRecord }
-      });
-    }
-
-    return null;
-  });
-
-  role_create = zodManage(z => z.object({
-    role_name: z.string(),
-    description: z.string(),
-  }), async (state, prisma) => {
-    const { role_name, description } = state.data;
-
-    state.okAdmin();
-
-    return await prisma.roles.create({
-      data: { role_name, description }
-    });
-
-  });
-
-  role_update = zodManage(z => z.object({
-    role_id: z.prismaField("Roles", "role_id", "number"),
-    role_name: z.prismaField("Roles", "role_name", "string"),
-    description: z.prismaField("Roles", "description", "string"),
-  }), async (state, prisma) => {
-    const { role_id, role_name, description } = state.data;
-
-    state.okUser();
-
-    if (role_id < 1) throw "Invalid role id";
-    if (role_id === 1) throw "Cannot update the admin role";
-    if (role_id === 2) throw "Cannot update the user role";
-
-    return await prisma.roles.update({
-      where: { role_id },
-      data: { role_name, description }
-    });
-
-  });
-
-}