@tiddlywiki/mws 0.0.12 → 0.0.13

package/src/utils/data-checks.ts

@@ -1,172 +0,0 @@
-import { Prisma } from "@prisma/client";
-import { truthy } from "./utils";
-import { ok } from "node:assert";
-
-
-export class DataChecks {
-  allowAnonReads;
-  allowAnonWrites;
-  constructor(options: { allowAnonReads?: boolean, allowAnonWrites?: boolean }) {
-    this.allowAnonReads = options.allowAnonReads;
-    this.allowAnonWrites = options.allowAnonWrites;
-  }
-
-  okTiddlerFields(tiddlerFields: Record<string, any>) {
-    ok(tiddlerFields.title, 'title must not be empty');
-    Object.entries(tiddlerFields).forEach(([key, value]) => {
-      if (typeof value === "undefined" || value === null) return;
-      ok(typeof value === "string", `tiddler fields must be a string, ${key} is ${typeof value}`);
-    });
-  }
-
-  okBagName(bagName: PrismaField<"Bags", "bag_name">) {
-    ok(typeof bagName === "string", 'bagName must be a string');
-    ok(bagName, 'bagName must not be empty');
-  }
-
-  okRecipeName(recipeName: PrismaField<"Recipes", "recipe_name">) {
-    ok(typeof recipeName === "string", 'recipeName must be a string');
-    ok(recipeName, 'recipeName must not be empty');
-  }
-
-  okUserID(userID: PrismaField<"Users", "user_id">) {
-    ok(typeof userID === "number", 'userID must be a number');
-    ok(userID > 0, 'userID must be greater than zero');
-  }
-
-  okTiddlerTitle(tiddlerTitle: string): asserts tiddlerTitle is PrismaField<"Tiddlers", "title"> {
-    ok(typeof tiddlerTitle === "string", 'tiddler title must be a string');
-    ok(tiddlerTitle, 'tiddler title must not be empty');
-  }
-
-  okEntityType(entityType: EntityType) {
-    ok(entityType === "bag" || entityType === "recipe", "Invalid entity type: " + entityType);
-  }
-
-  okEntityName(entityName: EntityName<EntityType>) {
-    ok(typeof entityName === "string", 'entityName must be a string');
-    ok(entityName, 'entityName must not be empty');
-  }
-
-  okSessionID(sessionID: string): asserts sessionID is PrismaField<"Sessions", "session_id"> {
-    ok(typeof sessionID === "string", 'sessionID must be a string');
-    ok(sessionID, 'sessionID must not be empty');
-  }
-
-  isPermissionName = <T extends string>(e: T): e is T & ACLPermissionName => {
-    const test = e as ACLPermissionName;
-    switch (test) {
-      case "ADMIN":
-      case "READ":
-      case "WRITE":
-        return true;
-      default: {
-        const _: never = test;
-        return false;
-      }
-    }
-  }
-
-  permissions: { [K in ACLPermissionName]: K } = { READ: "READ", WRITE: "WRITE", ADMIN: "ADMIN", };
-
-  isEntityType = (x: any): x is "recipe" | "bag" => ["recipe", "bag"].includes(x);
-
-  entityTypes: { [K in EntityType]: K } = { recipe: "recipe", bag: "bag" };
-
-  /** If the user isn't logged in, user_id is 0. */
-  getBagWhereACL({ recipe_id, permission, user_id, role_ids }: {
-    /** Recipe ID can be provided as an extra restriction */
-    recipe_id?: number,
-    permission: ACLPermissionName,
-    user_id: number,
-    role_ids: number[],
-  }) {
-
-    const OR = this.getWhereACL({ permission, user_id, role_ids });
-
-    return ([
-      // all system bags are allowed to be read by any user
-      permission === "READ" && { is_plugin: true },
-      ...OR,
-      // admin permission doesn't get inherited 
-      permission === "ADMIN" ? undefined : {
-        recipe_bags: {
-          some: {
-            // check if we're in position 0 (for write) or any position (for read)
-            position: permission === "WRITE" ? 0 : undefined,
-            // of a recipe that the user has this permission on
-            recipe: { OR },
-            // if the connection was created with admin permissions
-            with_acl: true,
-            // for the specific recipe, if provided
-            recipe_id,
-          }
-        }
-      }
-    ] satisfies (Prisma.BagsWhereInput | undefined | null | false)[]).filter(truthy)
-
-  }
-  getWhereACL({ permission, user_id, role_ids }: {
-    permission: ACLPermissionName,
-    user_id?: number,
-    role_ids?: number[],
-  }) {
-    const { allowAnonReads, allowAnonWrites } = this;
-    const anonRead = allowAnonReads && permission === "READ";
-    const anonWrite = allowAnonWrites && permission === "WRITE";
-    const allowAnon = anonRead || anonWrite;
-    const allperms = ["READ", "WRITE", "ADMIN"] as const;
-    const index = allperms.indexOf(permission);
-    if (index === -1) throw new Error("Invalid permission");
-    const checkPerms = allperms.slice(index);
-
-    return ([
-      // allow unowned for any user (conditional for anon reads)
-      (user_id || allowAnon) && { acl: { none: {} }, owner_id: null },
-      // allow owner for user 
-      user_id && { owner_id: user_id },
-      // allow acl for user 
-      user_id && role_ids?.length && {
-        acl: {
-          some: {
-            permission: { in: checkPerms },
-            role_id: { in: role_ids },
-          }
-        }
-      },
-      user_id && role_ids?.length && {
-        acl: {
-          some: {
-            permission: { in: checkPerms },
-            role_id: { in: role_ids },
-          }
-        }
-      },
-
-    ] satisfies (Prisma.RecipesWhereInput | Prisma.BagsWhereInput | undefined | null | false | 0)[]
-    ).filter(truthy)
-  }
-
-
-
-}
-
-
-
-/**
-## assumptions about prisma that should be tested
-
-```
-return await this.engine.acl.findMany({
-  where: {
-    entity_name: entityName,
-    entity_type: entityType,
-    // if permission_name is undefined, will prisma 
-    // include records without a permission connection?
-    // ChatGPT 03-mini-high doesn't think so.
-    permission: { permission_name } 
-  },
-});
-```
-*/
-declare let _dataChecks: any;

package/src/utils/index.ts

@@ -1,4 +0,0 @@
-export * from "./utils";
-export * from "./rootRoute";
-export * from "./data-checks";
-export * from "./zodAssert";

package/src/utils/rootRoute.ts

@@ -1,237 +0,0 @@
-import { AuthStateRouteACL, StateObject } from "../StateObject";
-import * as z from "zod";
-import { AllowedMethod, BodyFormat } from "../routes/router";
-
-
-export interface RouteOptAny extends RouteOptBase<BodyFormat, AllowedMethod[], string[]> { }
-
-export interface Route extends RouteDef<ParentTuple, string[]> { }
-
-export interface rootRoute extends RouteDef<[
-  undefined,
-  AllowedMethod[],
-  StateObject<BodyFormat, AllowedMethod>,
-  [[]]
-], []> { }
-
-export interface RouteMatch {
-  route: Route;
-  params: (string | undefined)[];
-  remainingPath: string;
-}
-
-type DetermineRouteOptions<
-  P extends ParentTuple, PA extends string[]
-> = P extends [BodyFormat, AllowedMethod[], any, any]
-  ?
-  RouteOptBase<P[0], P[1], PA> & { bodyFormat?: undefined; }
-  :
-  P extends [undefined, AllowedMethod[], any, any]
-  ?
-  | { [K in BodyFormat]: RouteOptBase<K, P[1], PA> & { bodyFormat: K; }; }[BodyFormat]
-  | RouteOptBase<BodyFormat, P[1], PA> & { bodyFormat?: undefined; }
-  : never;
-
-type ParentTuple = [BodyFormat | undefined, AllowedMethod[], any, string[][]];
-
-interface RouteOptBase<B extends BodyFormat, M extends AllowedMethod[], PA extends string[]> {
-
-  /** 
-   * Regex to test the pathname on. It must start with `^`. If this is a child route, 
-   * it will be tested against the remaining portion of the parent route.  
-   */
-  path: RegExp;
-  pathParams?: PA;
-  /** The uppercase method names to match this route */
-  method: M;
-  /** 
-   * The highest bodyformat in the chain always takes precedent. Type-wise, only one is allowed, 
-   * but at runtime the first one found is the one used. 
-   * 
-   * Note that bodyFormat is completely ignored for GET and HEAD requests.
-   */
-  bodyFormat?: B;
-  /** If this route is the last one matched, it will NOT be called, and a 404 will be returned. */
-  denyFinal?: boolean;
-}
-
-export interface RouteDef<P extends ParentTuple, PA extends string[]> extends RouteOptBase<P[0] & {}, P[1], PA> {
-
-  /**
-   * If this route's handler sends headers, the matched child route will not be called.
-   */
-  handler: (state: StateObject<P[0] extends undefined ? BodyFormat : (P[0] & {}), P[1][number], [...P[3], [...PA]], unknown>) => Promise<P[2]>
-
-  /**
-   * ### ROUTING
-   *
-   * @param route The route definition.
-   *
-   * If the parent route sends headers, or returns the STREAM_ENDED symbol, 
-   * this route will not be called.
-   *
-   * Inner routes are matched on the remaining portion of the parent route
-   * using `pathname.slice(match[0].length)`. If the parent route entirely 
-   * matches the pathname, this route will be matched on "/".
-   * 
-   * If the body format is "stream", "buffer", "ignore" or not yet defined at this level in the tree,
-   * then zod cannot be used. 
-   * 
-   * Note that GET and HEAD are always bodyFormat: "ignore", regardless of what is set here.
-   */
-  defineRoute: <R, PA extends string[],
-    // T extends DetermineRouteOptions<P, [...PA]>
-    T extends (P extends [BodyFormat, AllowedMethod[], any, any]
-    ?
-    RouteOptBase<P[0], P[1], [...PA]> & { bodyFormat?: undefined; }
-    :
-    P extends [undefined, AllowedMethod[], any, any]
-    ?
-    | { [K in BodyFormat]: RouteOptBase<K, P[1], [...PA]> & { bodyFormat: K; }; }[BodyFormat]
-    | RouteOptBase<BodyFormat, P[1], [...PA]> & { bodyFormat?: undefined; }
-    : never) 
-  > (
-    route: T,
-    handler: (
-      /** 
-       * The state object for this route.
-       * 
-       * If the route only specifies "GET" and/or "HEAD", then the bodyFormat can only be "ignore"
-       * 
-       * Otherwise, the bodyFormat is determined by the first parent route that specifies it.
-       * 
-       * The state object is wrapped in a proxy which throws if methods return a promise that 
-       * doesn't get awaited before the next property access. It only enforces the first layer 
-       * of properties, so if you have a nested object, you will need to wrap it in a proxy as well.
-       * 
-       * store and store.sql will probably also be wrapped in this proxy.
-       */
-      state: StateObject<
-        // if the route only specifies "GET" and/or "HEAD", then the bodyFormat can only be "ignore"
-        (Exclude<T["method"][number], "GET" | "HEAD"> extends never ? never : (
-          // parent route specified bodyFormat?
-          P[0] extends BodyFormat ? P[0] :
-          // this route specified bodyFormat?
-          T["bodyFormat"] extends BodyFormat ? T["bodyFormat"] :
-          // otherwise it could be anything
-          BodyFormat
-        )) | (
-          // GET and HEAD requests imply "ignore"
-          T["method"][number] extends "GET" | "HEAD" ? "ignore" : never
-        ),
-        // HTTP method
-        T["method"][number],
-        // possible placeholder for declaring routes
-        getPA<P, T>,
-        // infer zod, if set for this route
-        unknown
-      >) => Promise<R>
-  ) =>
-    P[0] extends BodyFormat ? RouteDef<[P[0], T["method"], R, P[3]], [...PA]> :
-    T["bodyFormat"] extends BodyFormat ? RouteDef<[T["bodyFormat"], T["method"], R, P[3]], [...PA]> :
-    RouteDef<[undefined, T["method"], R, P[3]], [...PA]>
-
-  $o?: P;
-}
-
-type getPA<P extends ParentTuple, T extends DetermineRouteOptions<P, any>> =
-  [...P[3], ...T["pathParams"] extends string[] ? [T["pathParams"]] : []];
-function test<T extends z.ZodTypeAny>(schema: { schema: T }): T {
-  return schema.schema;
-}
-const test1 = test({ schema: z.object({ test: z.string() }) })
-type t1 = typeof test1;
-type t2 = z.infer<t1>;
-
-
-
-/** This doesn't need to run, it's just to test types */
-function testroute(root: rootRoute) {
-
-  const test1 = root.defineRoute({
-    path: /^test/,
-    method: ["GET", "POST"],
-    bodyFormat: undefined,
-  }, async state => {
-    const test: BodyFormat = state.bodyFormat;
-  });
-
-  const test2_2 = test1.defineRoute({
-    path: /^test/,
-    bodyFormat: "www-form-urlencoded",
-    method: ["POST"],
-  }, async state => {
-    // zod: z.object({ test: z.string() }),
-
-
-  });
-
-  const test2 = test1.defineRoute({
-    path: /^test/,
-    bodyFormat: "string",
-    method: ["GET"],
-    zod: z.string(),
-    // handler: ,
-  }, async (state) => {
-    //@ts-expect-error because we didn't include "string"
-    const test: Exclude<BodyFormat, "ignore"> = state.bodyFormat;
-    // no error here if bodyFormat is correctly typed
-    const test2: "ignore" = state.bodyFormat
-    // @ts-expect-error because it should be "string"
-    state.isBodyFormat("buffer");
-    // this should never be an error unless something is really messed up
-    state.isBodyFormat("ignore");
-  });
-
-  const test3 = test2.defineRoute({
-    path: /^test/,
-    method: ["GET"],
-    // // @ts-expect-error because it's already been defined by the parent
-    // bodyFormat: "buffer",
-    zod: z.string(),
-  }, async (state) => {
-    //@ts-expect-error because we didn't include "string"
-    const test: Exclude<BodyFormat, "ignore"> = state.bodyFormat;
-    // no error here if bodyFormat is correctly typed
-    const test2: "ignore" = state.bodyFormat
-    // @ts-expect-error because it should be "string"
-    state.isBodyFormat("buffer");
-    // this should never be an error unless something is really messed up
-    state.isBodyFormat("ignore");
-  })
-
-  const test2post = test1.defineRoute({
-    path: /^test/,
-    bodyFormat: "string",
-    method: ["POST"],
-    zod: z.string(),
-    // handler: ,
-  }, async (state) => {
-    // @ts-expect-error because we didn't include "string"
-    const test: Exclude<BodyFormat, "string"> = state.bodyFormat;
-    // no error here if bodyFormat is correctly typed
-    const test2: "string" = state.bodyFormat
-    // @ts-expect-error because it should be "string"
-    state.isBodyFormat("buffer");
-    // this should never be an error unless something is really messed up
-    state.isBodyFormat("string");
-  });
-
-  const test3post = test2post.defineRoute({
-    path: /^test/,
-    method: ["POST"],
-    // // @ts-expect-error because it's already been defined by the parent
-    // bodyFormat: "buffer",
-    zod: z.string(),
-  }, async (state) => {
-    // @ts-expect-error because we didn't include "string"
-    const test: Exclude<BodyFormat, "string"> = state.bodyFormat;
-    // no error here if bodyFormat is correctly typed
-    const test2: "string" = state.bodyFormat
-    // @ts-expect-error because it should be "string"
-    state.isBodyFormat("buffer");
-    // this should never be an error unless something is really messed up
-    state.isBodyFormat("string");
-  })
-}
-