@tiddlywiki/mws 0.0.12 → 0.0.13

package/src/utils/utils.ts

@@ -1,403 +0,0 @@
-import { IncomingHttpHeaders, OutgoingHttpHeaders } from "node:http";
-import { Streamer } from "../streamer";
-import { StateObject } from '../StateObject';
-import { createHash } from "node:crypto";
-import * as zlib from "node:zlib";
-import { ok } from "node:assert";
-import { promisify } from "node:util";
-import { SiteConfig } from "../routes/router";
-import * as path from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-/**
-Options include:
-- `cbPartStart(headers,name,filename)` - invoked when a file starts being received
-- `cbPartChunk(chunk)` - invoked when a chunk of a file is received
-- `cbPartEnd()` - invoked when a file finishes being received
-- `cbFinished(err)` - invoked when the all the form data has been processed
-*/
-export function readMultipartData(this: StateObject<any, any>, options: {
-  cbPartStart: (headers: IncomingHttpHeaders, name: string | null, filename: string | null) => void,
-  cbPartChunk: (chunk: Buffer) => void,
-  cbPartEnd: () => void,
-  cbFinished: (err: Error | string | null) => void
-}) {
-  return new Promise<void>((resolve, reject) => {
-    // Check that the Content-Type is multipart/form-data
-    const contentType = this.headers['content-type'];
-    if (!contentType?.startsWith("multipart/form-data")) {
-      return reject("Expected multipart/form-data content type");
-    }
-    // Extract the boundary string from the Content-Type header
-    const boundaryMatch = contentType.match(/boundary=(.+)$/);
-    if (!boundaryMatch) {
-      return reject("Missing boundary in multipart/form-data");
-    }
-    const boundary = boundaryMatch[1];
-    const boundaryBuffer = Buffer.from("--" + boundary);
-    // Initialise
-    let buffer = Buffer.alloc(0);
-    let processingPart = false;
-    // Process incoming chunks
-    this.reader.on("data", (chunk) => {
-      // Accumulate the incoming data
-      buffer = Buffer.concat([buffer, chunk]);
-      // Loop through any parts within the current buffer
-      while (true) {
-        if (!processingPart) {
-          // If we're not processing a part then we try to find a boundary marker
-          const boundaryIndex = buffer.indexOf(boundaryBuffer);
-          if (boundaryIndex === -1) {
-            // Haven't reached the boundary marker yet, so we should wait for more data
-            break;
-          }
-          // Look for the end of the headers
-          const endOfHeaders = buffer.indexOf("\r\n\r\n", boundaryIndex + boundaryBuffer.length);
-          if (endOfHeaders === -1) {
-            // Haven't reached the end of the headers, so we should wait for more data
-            break;
-          }
-          // Extract and parse headers
-          const headersPart = Uint8Array.prototype.slice.call(buffer, boundaryIndex + boundaryBuffer.length, endOfHeaders).toString();
-          const currentHeaders: IncomingHttpHeaders = {};
-          headersPart.split("\r\n").forEach(headerLine => {
-            const [key, value] = headerLine.split(": ");
-            ok(typeof key === "string");
-            currentHeaders[key.toLowerCase()] = value;
-          });
-          // Parse the content disposition header
-          const contentDisposition: {
-            name: string | null,
-            filename: string | null
-          } = {
-            name: null,
-            filename: null
-          };
-          if (currentHeaders["content-disposition"]) {
-            // Split the content-disposition header into semicolon-delimited parts
-            const parts = currentHeaders["content-disposition"].split(";").map(part => part.trim());
-            // Iterate over each part to extract name and filename if they exist
-            parts.forEach(part => {
-              if (part.startsWith("name=")) {
-                // Remove "name=" and trim quotes
-                contentDisposition.name = part.substring(6, part.length - 1);
-              } else if (part.startsWith("filename=")) {
-                // Remove "filename=" and trim quotes
-                contentDisposition.filename = part.substring(10, part.length - 1);
-              }
-            });
-          }
-          processingPart = true;
-          options.cbPartStart(currentHeaders, contentDisposition.name, contentDisposition.filename);
-          // Slice the buffer to the next part
-          buffer = Buffer.from(buffer, endOfHeaders + 4);
-        } else {
-          const boundaryIndex = buffer.indexOf(boundaryBuffer);
-          if (boundaryIndex >= 0) {
-            // Return the part up to the boundary minus the terminating LF CR
-            options.cbPartChunk(Buffer.from(buffer, 0, boundaryIndex - 2));
-            options.cbPartEnd();
-            processingPart = false;
-            // this starts at the boundary marker, which gets picked up on the next loop
-            buffer = Buffer.from(buffer, boundaryIndex);
-          } else {
-            // Return the rest of the buffer
-            options.cbPartChunk(buffer);
-            // Reset the buffer and wait for more data
-            buffer = Buffer.alloc(0);
-            break;
-          }
-        }
-      }
-    });
-
-    // All done
-    this.reader.on("end", () => {
-      resolve();
-    });
-  }).then(() => {
-    options.cbFinished(null);
-  }, (err) => {
-    options.cbFinished(err);
-    throw err;
-  });
-
-}
-
-
-
-/*
-Send a response to the client. This method checks if the response must be sent
-or if the client alrady has the data cached. If that's the case only a 304
-response will be transmitted and the browser will use the cached data.
-Only requests with status code 200 are considdered for caching.
-request: request instance passed to the handler
-response: response instance passed to the handler
-statusCode: stauts code to send to the browser
-headers: response headers (they will be augmented with an `Etag` header)
-data: the data to send (passed to the end method of the response instance)
-encoding: the encoding of the data to send (passed to the end method of the response instance)
-*/
-export async function sendResponse(config: SiteConfig, state: StateObject<any, any>, statusCode: number, headers: OutgoingHttpHeaders, data: string | Buffer, encoding?: NodeJS.BufferEncoding) {
-  // console.log("sendResponse");
-  if (config.enableBrowserCache && (statusCode == 200)) {
-    // console.log("enableBrowserCache");
-    var hash = createHash('md5');
-    // Put everything into the hash that could change and invalidate the data that
-    // the browser already stored. The headers the data and the encoding.
-    hash.update(data);
-    hash.update(JSON.stringify(headers));
-    if (encoding) {
-      hash.update(encoding);
-    }
-    var contentDigest = hash.digest("hex");
-    // RFC 7232 section 2.3 mandates for the etag to be enclosed in quotes
-    headers["Etag"] = '"' + contentDigest + '"';
-    headers["Cache-Control"] = "max-age=0, must-revalidate";
-    // Check if any of the hashes contained within the if-none-match header
-    // matches the current hash.
-    // If one matches, do not send the data but tell the browser to use the
-    // cached data.
-    // We do not implement "*" as it makes no sense here.
-    var ifNoneMatch = state.headers["if-none-match"];
-    if (ifNoneMatch) {
-      var matchParts = ifNoneMatch.split(",").map(function (etag) {
-        return etag.replace(/^[ "]+|[ "]+$/g, "");
-      });
-      if (matchParts.indexOf(contentDigest) != -1) {
-        return state.sendEmpty(304, headers);
-      }
-    }
-  }
-  /*
-  If the gzip=yes is set, check if the user agent permits compression. If so,
-  compress our response if the raw data is bigger than 2k. Compressing less
-  data is inefficient.
-  */
-  if (config.enableGzip && (data.length > 2048)) {
-    var acceptEncoding = state.headers["accept-encoding"] || "";
-    if (/\bdeflate\b/.test(acceptEncoding)) {
-      headers["Content-Encoding"] = "deflate";
-      data = await promisify(zlib.deflate)(data);
-    } else if (/\bgzip\b/.test(acceptEncoding)) {
-      headers["Content-Encoding"] = "gzip";
-      data = await promisify(zlib.gzip)(data);
-    }
-  }
-  if (typeof data === "string") {
-    ok(encoding, "encoding must be set for string data");
-    return state.sendString(statusCode, headers, data, encoding);
-  } else {
-    return state.sendBuffer(statusCode, headers, data);
-  }
-}
-
-
-interface Route {
-  useACL: any;
-  method: string;
-  entityName: any;
-  csrfDisable: any;
-  bodyFormat: string;
-  path: { source: string; };
-  handler: (streamer: Streamer) => void;
-};
-
-interface State {
-  wiki: any;
-  boot: any;
-  server: any;
-  urlInfo: any;
-  queryParameters: any;
-  pathPrefix: string;
-  sendResponse: any;
-  redirect: any;
-  streamMultipartData: any;
-  authenticatedUser: any;
-  authenticatedUsername: any;
-  authorizationType: string;
-  allowAnon: boolean;
-  anonAccessConfigured: boolean;
-  allowAnonReads: boolean;
-  allowAnonWrites: boolean;
-  showAnonConfig: boolean;
-  firstGuestUser: boolean;
-  data?: any;
-}
-
-interface Server {
-  enableBrowserCache: boolean;
-  enableGzip: boolean;
-  get: (key: string) => any;
-  methodMappings: { [key: string]: string };
-  isAuthorized: (authorizationType: string, username: string) => boolean;
-  getAnonymousAccessConfig: () => { allowReads: boolean; allowWrites: boolean; isEnabled: boolean; showAnonConfig: boolean };
-  sqlTiddlerDatabase: any;
-  servername: string;
-  findMatchingRoute: (request: Streamer, state: State) => Route;
-  authenticateUser: (request: Streamer, response: Streamer) => any;
-  methodACLPermMappings: { [key: string]: string };
-  csrfDisable: boolean;
-  wiki: any;
-  boot: any;
-}
-
-
-export function is<T>(a: any, b: boolean): a is T { return b; }
-
-/** Initiates a timer that must get cancelled before the current turn of the event loop ends */
-export class SyncCheck {
-  done;
-  constructor() {
-    let cancelled = false;
-    const error = new Error("SyncCheck was not completed before the current turn of the event loop ended");
-    process.nextTick(() => {
-      if (cancelled) return;
-      console.log(error);
-      process.exit(1);
-    });
-    this.done = () => { cancelled = true };
-  }
-}
-
-
-/** 
- * If any property returns a function, and that function returns a promise, 
- * the proxy will throw an error if the promise is not awaited before the next property access.
- * 
- * The stack trace of the error will point to the line where the promise was returned.
- */
-export function createStrictAwaitProxy<T extends object>(instance: T): T {
-  let outstandingPromiseError: Error | null = null;
-
-  function wrappedFunction(value: Function) {
-    return function (this: any, ...args: any[]) {
-      // Protect against calling any methods while an outstanding promise exists.
-
-      // Call the original function preserving the correct "this" context.
-      const result = Reflect.apply(value, this, args);
-      // If the result is a promise, wrap it to clear the outstanding lock on await.
-      if (result instanceof Promise) {
-        return new Proxy(result, {
-          get(promiseTarget, promiseProp, promiseReceiver) {
-            // When the promise's then property is accessed (i.e. when it's awaited),
-            // clear the outstanding promise so that subsequent method calls are allowed.
-            if (promiseProp === "then") {
-              outstandingPromiseError = null;
-            }
-            const inner = Reflect.get(promiseTarget, promiseProp, promiseReceiver).bind(promiseTarget);
-            if (promiseProp === "catch") {
-              return wrappedFunction(inner);
-            }
-            return inner;
-          }
-        });
-      }
-      return result;
-    }
-  }
-
-  return new Proxy(instance, {
-    get(target, prop, receiver) {
-      // throw an error if an outstanding promise exists.
-      if (outstandingPromiseError !== null) {
-        throw outstandingPromiseError;
-      }
-      // Use Reflect.get to get the property value.
-      const value = Reflect.get(target, prop, receiver);
-
-      // If the property is a function, return a wrapped function.
-      if (typeof value === "function") {
-        return wrappedFunction(value);
-      }
-      // For non-function properties, just return the value.
-      return value;
-    }
-  });
-}
-
-export function tryParseJSON<T>(json: string): T | undefined {
-  try {
-    return JSON.parse(json);
-  } catch {
-    return undefined;
-  }
-}
-
-
-export class TypedGenerator<T extends [any, any][]> {
-  static checker<T extends [any, any][]>() {
-    return {
-      /** `const value1 = asV(1, yield asY(0, value0))` */
-      asV<I extends number>(index: I, args: T[I][0]): T[I][0] { return args; },
-      /** `const value1 = asV(1, yield asY(0, value0))` */
-      asY<I extends number>(index: I, ret: T[I][1]): T[I][1] { return ret; },
-    }
-  }
-  static wrapper<T extends [any, any][]>() {
-    return <A extends any[]>(factory: (...args: A) => Generator<any, any, any>) => {
-      return (...args: A) => new TypedGenerator<T>(factory(...args));
-    };
-  }
-  constructor(private inner: Generator<any, any, any>, private index = 0) { }
-  async next<I extends number>(index: I, ...args: T[I][0] extends void ? [] : [T[I][0]]): Promise<(
-    T extends [...any[], T[I]] ? IteratorReturnResult<T[I][1]> : IteratorYieldResult<T[I][1]>
-  )> {
-    if (index !== this.index) throw new Error("Invalid index");
-    this.index++;
-    return this.inner.next(...args) as any;
-  }
-  return(value: any): any { this.inner.return(value); }
-  throw(e: any): any { this.inner.throw(e); }
-}
-
-export async function mapAsync<T, U, V>(array: T[], callback: (this: V, value: T, index: number, array: T[]) => Promise<U>, thisArg?: any): Promise<U[]> {
-  const results = new Array(array.length);
-  for (let index = 0; index < array.length; index++) {
-    results[index] = await callback.call(thisArg, array[index] as T, index, array);
-  }
-  return results;
-};
-
-export async function filterAsync<T, V>(array: T[], callback: (this: V, value: T, index: number, array: T[]) => Promise<boolean>, thisArg?: any): Promise<T[]> {
-  const results = [];
-  for (let index = 0; index < array.length; index++) {
-    if (await callback.call(thisArg, array[index] as T, index, array)) {
-      results.push(array[index]);
-    }
-  }
-  return results as any;
-}
-
-
-export function truthy<T>(
-  obj: T
-): obj is Exclude<T, false | null | undefined | 0 | '' | void> {
-  return !!obj;
-}
-
-
-export class UserError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "UserError";
-  }
-}
-/** 
- * This returns the resolved path relative to the executing code file, 
- * however it uses path.resolve, not require.resolve. 
- */
-
-export function dist_resolve(filepath: string) {
-  const filename = typeof module === "undefined" ? fileURLToPath(import.meta.url) : module.filename;
-  return path.resolve(path.dirname(filename), filepath);
-}
-export function dist_require_resolve(filepath: string) {
-  const filename = typeof module === "undefined" ? fileURLToPath(import.meta.url) : module.filename;
-  return createRequire(filename).resolve(filepath);
-}
-
-
-export declare interface JsonArray extends Array<JsonValue> { }
-export declare type JsonObject = { [Key in string]?: JsonValue; };
-export declare type JsonValue = string | number | boolean | JsonObject | JsonArray | null | Date;

package/src/utils/zodAssert.ts

@@ -1,269 +0,0 @@
-import { z, ZodEffects } from "zod";
-import { StateObject } from "../StateObject";
-import { Prisma } from "@prisma/client";
-import { STREAM_ENDED } from "../streamer";
-
-
-
-export namespace ZodAssert {
-  type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>
-  /** 
-   * assert zod on the request body (`state.data`). 
-   * 
-   * You cannot assert data on a stream or ignore body format.
-   * 
-   * Attempting to do so will cause the schema argument to expect a string 
-   * containing an error message informing the developer of this.
-  */
-  export function data<T extends
-    S extends StateObject<"ignore" | "stream"> ? z.ZodUnknown :
-    S extends StateObject<"www-form-urlencoded"> ? z.ZodObject<any> :
-    z.ZodTypeAny, S extends StateObject
-  >(
-    state: S,
-    schema:
-      S extends StateObject<"ignore" | "stream">
-      ? "it is invalid to assert data for this body format"
-      : (zod: S extends StateObject<"www-form-urlencoded"> ? Z2<"STRING"> : Z2<"JSON">) => T,
-    /** 
-     * If the data does not match the schema, this function is called sync'ly with the zod error.
-     * Whatever it returns is sent as a utf8 string response body.
-     * @param error The zod error.
-     * @returns A string to send as the response body, or void to use the default error message.
-     */
-    onError?: (error: z.ZodError<any>) => string | void
-  ): asserts state is S & ({ data: z.infer<T> }) {
-    _zodAssert("data", state, schema as any, onError);
-  }
-
-  /** 
-   * assert zod on the route path match groups (`state.pathParams`). 
-   * 
-   * Sends a 404 response instead of 400. 
-  */
-  export function pathParams<
-    T extends Exactly<{ [k in keyof S["pathParams"]]: z.ZodTypeAny; }, T>,
-    S extends StateObject,
-  >(
-    state: S, schemaShape: (zod: Z2<"STRING">) => T,
-    /** 
-     * If the data does not match the schema, this function is called sync'ly with the zod error.
-     * Whatever it returns is sent as a utf8 string response body.
-     * @param error The zod error.
-     * @returns A string to send as the response body, or void to use the default error message.
-     */
-    onError?: (error: z.ZodError<any>) => string | void
-  ): asserts state is S & ({ pathParams: z.infer<z.ZodObject<T>> }) {
-    _zodAssert("pathParams", state, schemaShape, onError);
-  }
-
-  /** 
-   * assert zod on the url query parameters (`state.queryParams`). 
-   * 
-   * This is the only place that the query parameters are declared, so the keys are not checked. 
-   * 
-   * If no value is specified, it defaults to an empty string
-   * (`?key&key=&key` becomes `key: ["", "", ""]`).
-   * 
-   * In zod: `z.object({ key: z.array(z.string()).optional() })`
-   */
-  export function queryParams<T extends Record<string, z.ZodTypeAny>, S extends StateObject>(
-    state: S, schemaShape: (zod: Z2<"STRING">) => T,
-    /** 
-     * If the data does not match the schema, this function is called sync'ly with the zod error.
-     * Whatever it returns is sent as a utf8 string response body.
-     * @param error The zod error.
-     * @returns A string to send as the response body, or void to use the default error message.
-     */
-    onError?: (error: z.ZodError<any>) => string | void
-  ): asserts state is S & ({ queryParams: z.infer<z.ZodObject<T>> }) {
-    _zodAssert("queryParams", state, schemaShape, onError);
-  }
-  /** 
-   * assert zod on the data passed to this function and returns the cleaned data.
-   * If onError is not specified, or does not return STREAM_ENDED, an error 500 is sent. 
-   * Either way, zodAssert will throw STREAM_ENDED immediately.
-   * 
-   * If onError is not specified, the error will be printed with console.log.
-   */
-  export function any<T extends z.ZodTypeAny, S extends StateObject>(
-    state: S, schemaShape: (zod: Z2<"JSON">) => T, data: z.input<T>,
-    /** 
-     * If the data does not match the schema, this function is called sync'ly with the zod error.
-     * If it does not return the STREAM_ENDED symbol indicating an appropriate error response was sent, 
-     * zodAssert will throw with a 500 error.
-     * 
-     * It is perfectly valid to throw an error from this function,
-     * as zodAssert will throw STREAM_ENDED immediately if it returns.
-     * 
-     * @param error The zod error.
-     * @returns STREAM_ENDED to indicate an appropriate error response was sent, or undefined.
-     */
-    onError?: (error: z.ZodError<any>) => void | symbol
-  ): z.infer<T> { return _zodAssertAny("any", state, schemaShape, data, onError); }
-  /** 
-   * assert zod on the data passed to this function and returns the cleaned data.
-   * If onError is not specified, or does not return STREAM_ENDED, an error 500 is sent. 
-   * Either way, zodAssert will throw STREAM_ENDED immediately.
-   * 
-   * If onError is not specified, the error will be printed with console.log.
-   */
-  export function response<T extends z.ZodTypeAny, S extends StateObject>(
-    state: S, schemaShape: (zod: Z2<"JSON">) => T, data: z.input<T>,
-    /** 
-     * If the data does not match the schema, this function is called sync'ly with the zod error.
-     * If it does not return the STREAM_ENDED symbol indicating an appropriate error response was sent, 
-     * zodAssert will throw with a 500 error.
-     * 
-     * It is perfectly valid to throw an error from this function,
-     * as zodAssert will throw STREAM_ENDED immediately if it returns.
-     * 
-     * @param error The zod error.
-     * @returns STREAM_ENDED to indicate an appropriate error response was sent, or undefined.
-     */
-    onError?: (error: z.ZodError<any>) => void | symbol
-  ): z.infer<T> { return _zodAssertAny("response", state, schemaShape, data, onError); }
-
-
-}
-// type t = number extends PrismaPayloadScalars<"Roles">["role_id"] ? FieldTypeNumberSelector<"JSON"> : false;
-export interface Z2<T extends FieldTypeGroups> extends _zod {
-  /** 
-   * Tags the resulting value as being from the specified table field.
-   * 
-   * The third argument is a string literal that specifies the field type based on the selected field.
-   * 
-   * "string" and "parse-number" 
-   * - will use decodeURIComponent on the value. 
-   * - Require a string length at least one
-   * 
-   * You can use .optional(), .nullable(), .nulish() after this to make the field optional.
-   */
-  prismaField<Table extends Prisma.ModelName, Field extends keyof PrismaPayloadScalars<Table>>(
-    table: Table, field: Field,
-    fieldtype:
-      string extends (PrismaPayloadScalars<Table>[Field]) ? FieldTypeStringSelector<T> :
-      number extends (PrismaPayloadScalars<Table>[Field]) ? FieldTypeNumberSelector<T> :
-      boolean extends (PrismaPayloadScalars<Table>[Field]) ? FieldTypeBooleanSelector<T> :
-      never,
-    nullable?: null extends PrismaPayloadScalars<Table>[Field] ? true : false
-  ): ZodEffects<any, PrismaField<Table, Field>, PrismaPayloadScalars<Table>[Field]>;
-
-
-  authUser(): z.ZodNullable<z.ZodObject<{
-    user_id: z.ZodNumber;
-    isAdmin: z.ZodBoolean;
-    username: z.ZodString;
-    sessionId: z.ZodNumber;
-  }>>;
-
-}
-
-export const _zodAssertAny = (
-  input: string,
-  state: StateObject,
-  schema: (z: Z2<any>) => z.ZodTypeAny | Record<string, z.ZodTypeAny>,
-  inputdata: any,
-  onError?: (error: z.ZodError<any>) => symbol | void,
-) => {
-  const schema2: any = schema(makeZ2(input));
-  const { success, data, error } = z.any().pipe(schema2).safeParse(inputdata);
-  if (!success) {
-    if (!onError) error.issues.forEach(e => console.log(input, e.message, e.path));
-    if (onError?.(error) === STREAM_ENDED) throw STREAM_ENDED;
-    throw state.sendEmpty(500, { "x-reason": input });
-  }
-  return data;
-}
-
-const _zodAssert = (
-  input: "data" | "pathParams" | "queryParams",
-  state: StateObject,
-  schema: (z: Z2<any>) => z.ZodTypeAny | Record<string, z.ZodTypeAny>,
-  onError?: (error: z.ZodError<any>) => string | void,
-) => {
-
-  // this checks if the schema is a string, since that is used to indicate invalid use cases of zodAssert,
-  // and if it's correctly typed, then this is the best way to find it.
-  if (typeof schema === "string") {
-    console.log(new Error(`schema is a string: ${schema}`));
-    throw state.sendEmpty(500);
-  }
-  const schema2: any = schema(makeZ2(input));
-
-  const { success, data, error } = z.any().pipe(
-    input === "data" ? schema2 : z.object(schema2)
-  ).safeParse(state[input]);
-  if (!success) {
-    if (!onError) error.issues.forEach(e => console.log(input, e.message, e.path));
-    const status = input === "pathParams" ? 404 : 400;
-    const message = onError?.(error);
-    if (typeof message === "string")
-      throw state.sendString(status, { "x-reason": input }, message ?? "", "utf8");
-    else
-      throw state.sendEmpty(status, { "x-reason": input });
-  }
-  state[input] = data;
-};
-
-type _zod = typeof z;
-type ExtraFieldType = "string" | "number" | "parse-number" | "boolean" | "parse-boolean";
-type FieldTypeGroups = "STRING" | "JSON";
-type FieldTypeStringSelector<T extends FieldTypeGroups> = T extends "STRING" ? "string" : "string";
-type FieldTypeNumberSelector<T extends FieldTypeGroups> = T extends "STRING" ? "parse-number" : "number";
-type FieldTypeBooleanSelector<T extends FieldTypeGroups> = T extends "STRING" ? "parse-boolean" : "boolean";
-
-export const Z2 = makeZ2("any");
-
-
-function makeZ2<T extends FieldTypeGroups>(input: "data" | "pathParams" | "queryParams" | "any" | "response" | string): Z2<T> {
-  const z2 = Object.create(z);
-  z2.prismaField = prismaField;
-  z2.authUser = () => z.object({
-    user_id: z.number(),
-    isAdmin: z.boolean(),
-    username: z.string(),
-    sessionId: z.number(),
-  }).nullable();
-  return z2;
-}
-
-
-function prismaField(table: any, field: any, fieldtype: ExtraFieldType, nullable?: boolean): any {
-  const check = (() => {
-    switch (fieldtype) {
-      case "string":
-        return z.string()
-          .refine(x => x.length, { message: "String must have length" });
-      case "parse-number":
-        return z.string().min(1)
-          .pipe(z.bigint({ coerce: true }))
-          .pipe(z.number({ coerce: true }).finite())
-          .refine(x => !isNaN(x), { message: "Invalid number" });
-      case "parse-boolean":
-        return z.enum(["true", "false", "null"]).transform(x => x === "null" ? null : x === "true");
-      case "boolean":
-        return z.boolean();
-      case "number":
-        return z.number().finite().int();
-      default:
-        throw new Error("Invalid field type");
-    }
-  })();
-  return nullable ? check.nullable() : check;
-
-}
-
-
-// const zodAssertGlobal = {
-//   data: _zodAssert.bind(null, "data"),
-//   pathParams: _zodAssert.bind(null, "pathParams"),
-//   queryParams: _zodAssert.bind(null, "queryParams"),
-//   response: _zodAssertAny.bind(null, "response"),
-//   any: _zodAssertAny.bind(null, "any"),
-//   zod: makeZ2("any"),
-// };
-
-// declare global { type ZodAssert = typeof zodAssertGlobal; }
-
-// type t = ZodAssert;