vovk 3.0.0-draft.74 → 3.0.0-draft.75

package/src/client/types.ts

@@ -1,120 +0,0 @@
-import type {
-  KnownAny,
-  HttpMethod,
-  ControllerStaticMethod,
-  VovkControllerBody,
-  VovkControllerQuery,
-  VovkControllerParams,
-  VovkHandlerSchema,
-  VovkControllerSchema,
-} from '../types';
-import type { StreamJSONResponse } from '../StreamJSONResponse';
-import type { NextResponse } from 'next/server';
-
-export type StaticMethodInput<T extends ControllerStaticMethod> = (VovkControllerBody<T> extends undefined | void
-  ? { body?: undefined }
-  : VovkControllerBody<T> extends null
-    ? { body?: null }
-    : { body: VovkControllerBody<T> }) &
-  (VovkControllerQuery<T> extends undefined | void ? { query?: undefined } : { query: VovkControllerQuery<T> }) &
-  (VovkControllerParams<T> extends undefined | void ? { params?: undefined } : { params: VovkControllerParams<T> });
-
-type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
-
-export type VovkStreamAsyncIterable<T> = {
-  status: number;
-  [Symbol.dispose](): Promise<void> | void;
-  [Symbol.asyncDispose](): Promise<void> | void;
-  [Symbol.asyncIterator](): AsyncIterator<T>;
-  cancel: () => Promise<void> | void;
-};
-
-type StaticMethodReturn<T extends ControllerStaticMethod> =
-  ReturnType<T> extends NextResponse<infer U> | Promise<NextResponse<infer U>>
-    ? U
-    : ReturnType<T> extends Response | Promise<Response>
-      ? Awaited<ReturnType<T>>
-      : ReturnType<T>;
-
-type StaticMethodReturnPromise<T extends ControllerStaticMethod> = ToPromise<StaticMethodReturn<T>>;
-
-type ClientMethod<
-  T extends (...args: KnownAny[]) => void | object | StreamJSONResponse<STREAM> | Promise<StreamJSONResponse<STREAM>>,
-  OPTS extends Record<string, KnownAny>,
-  STREAM extends KnownAny = unknown,
-> = (<R>(
-  options: (StaticMethodInput<T> extends { body?: undefined | null; query?: undefined; params?: undefined }
-    ? unknown
-    : Parameters<T>[0] extends void
-      ? StaticMethodInput<T>['params'] extends object
-        ? { params: StaticMethodInput<T>['params'] }
-        : unknown
-      : StaticMethodInput<T>) &
-    (Partial<
-      OPTS & {
-        transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>) => R;
-      }
-    > | void)
-) => ReturnType<T> extends
-  | Promise<StreamJSONResponse<infer U>>
-  | StreamJSONResponse<infer U>
-  | Iterator<infer U>
-  | AsyncIterator<infer U>
-  ? Promise<VovkStreamAsyncIterable<U>>
-  : R extends object
-    ? Promise<R>
-    : StaticMethodReturnPromise<T>) & {
-  schema: VovkHandlerSchema;
-  controllerSchema: VovkControllerSchema;
-};
-
-type OmitNever<T> = {
-  [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-
-type VovkClientWithNever<T, OPTS extends { [key: string]: KnownAny }> = {
-  [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], OPTS> : never;
-};
-
-export type VovkClient<T, OPTS extends { [key: string]: KnownAny }> = OmitNever<VovkClientWithNever<T, OPTS>>;
-
-export type VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<string, never>, T = KnownAny> = (
-  options: {
-    name: keyof T;
-    httpMethod: HttpMethod;
-    getEndpoint: (data: {
-      apiRoot: string;
-      params: { [key: string]: string };
-      query: { [key: string]: string };
-    }) => string;
-    validate: (input: { body?: unknown; query?: unknown; endpoint: string }) => void | Promise<void>;
-    defaultStreamHandler: (response: Response) => Promise<VovkStreamAsyncIterable<unknown>>;
-    defaultHandler: (response: Response) => Promise<unknown>;
-  },
-  input: {
-    body: unknown;
-    query: { [key: string]: string };
-    params: { [key: string]: string };
-  } & OPTS
-) => KnownAny;
-
-// `RequestInit` is the type of options passed to fetch function
-export interface VovkDefaultFetcherOptions extends Omit<RequestInit, 'body' | 'method'> {
-  reactNative?: { textStreaming: boolean };
-  apiRoot?: string;
-  segmentName?: string;
-  disableClientValidation?: boolean;
-  validateOnClient?: VovkValidateOnClient;
-  fetcher?: VovkClientFetcher;
-}
-
-export type VovkValidateOnClient = (
-  input: { body?: unknown; query?: unknown; endpoint: string },
-  validators: { body?: unknown; query?: unknown }
-) => void | Promise<void>;
-
-export type VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
-  fetcher?: VovkClientFetcher<OPTS>;
-  validateOnClient?: VovkValidateOnClient;
-  defaultOptions?: Partial<OPTS>;
-};

package/src/createDecorator.ts

@@ -1,61 +0,0 @@
-import type { VovkHandlerSchema, KnownAny, VovkController, VovkRequest } from './types';
-
-type Next = () => Promise<unknown>;
-
-export function createDecorator<ARGS extends unknown[], REQUEST = VovkRequest>(
-  handler: null | ((this: VovkController, req: REQUEST, next: Next, ...args: ARGS) => unknown),
-  initHandler?: (
-    this: VovkController,
-    ...args: ARGS
-  ) =>
-    | Omit<VovkHandlerSchema, 'path' | 'httpMethod'>
-    | ((handlerSchema: VovkHandlerSchema | null) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>)
-    | null
-    | undefined
-) {
-  return function decoratorCreator(...args: ARGS) {
-    return function decorator(target: KnownAny, propertyKey: string) {
-      const controller = target as VovkController;
-
-      const originalMethod = controller[propertyKey] as ((...args: KnownAny) => KnownAny) & {
-        _sourceMethod?: ((...args: KnownAny) => KnownAny);
-        _onSettled?: (controller: VovkController) => void;
-      };
-      if (typeof originalMethod !== 'function') {
-        throw new Error(`Unable to decorate: ${propertyKey} is not a function`);
-      }
-      const sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-
-      const method = function method(req: REQUEST, params?: unknown) {
-        const next: Next = async () => {
-          return (await originalMethod.call(controller, req, params)) as unknown;
-        };
-
-        return handler ? handler.call(controller, req, next, ...args) : next();
-      };
-
-      controller[propertyKey] = method;
-
-      method._controller = controller;
-      method._sourceMethod = sourceMethod;
-      // TODO define internal method type
-      (originalMethod as unknown as { _controller: VovkController })._controller = controller;
-      originalMethod?._onSettled?.(controller);
-
-      const handlerSchema: VovkHandlerSchema | null = controller._handlers?.[propertyKey] ?? null;
-      const initResultReturn = initHandler?.call(controller, ...args);
-      const initResult = typeof initResultReturn === 'function' ? initResultReturn(handlerSchema) : initResultReturn;
-
-      controller._handlers = {
-        ...controller._handlers,
-        [propertyKey]: {
-          ...handlerSchema,
-          // avoid override of path and httpMethod
-          ...(initResult?.validation ? { validation: initResult.validation } : {}),
-          ...(initResult?.openapi ? { openapi: initResult.openapi } : {}),
-          ...(initResult?.custom ? { custom: initResult.custom } : {}),
-        },
-      };
-    };
-  };
-}

package/src/createVovkApp.ts

@@ -1,168 +0,0 @@
-import type { NextRequest } from 'next/server';
-import { VovkApp as VovkApp } from './VovkApp';
-import {
-  HttpMethod,
-  type KnownAny,
-  type RouteHandler,
-  type VovkController,
-  type DecoratorOptions,
-  type VovkRequest,
-  type StaticClass,
-  VovkHandlerSchema,
-} from './types';
-import getSchema from './utils/getSchema';
-
-const trimPath = (path: string) => path.trim().replace(/^\/|\/$/g, '');
-const isClass = (func: unknown) => typeof func === 'function' && /class/.test(func.toString());
-const toKebabCase = (str: string) =>
-  str
-    .replace(/([A-Z])/g, '-$1')
-    .toLowerCase()
-    .replace(/^-/, '');
-
-export function createVovkApp() {
-  const vovkApp = new VovkApp();
-
-  const createHTTPDecorator = (httpMethod: HttpMethod) => {
-    const assignSchema = (
-      controller: VovkController,
-      propertyKey: string,
-      path: string,
-      options?: DecoratorOptions
-    ) => {
-      if (typeof window !== 'undefined') {
-        throw new Error(
-          'Decorators are intended for server-side use only. You have probably imported a controller on the client-side.'
-        );
-      }
-      if (!isClass(controller)) {
-        let decoratorName = httpMethod.toLowerCase();
-        if (decoratorName === 'delete') decoratorName = 'del';
-        throw new Error(
-          `Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}.`
-        );
-      }
-
-      const methods: Record<string, RouteHandler> = vovkApp.routes[httpMethod].get(controller) ?? {};
-      vovkApp.routes[httpMethod].set(controller, methods);
-
-      controller._handlers = {
-        ...controller._handlers,
-        [propertyKey]: {
-          ...((controller._handlers ?? {})[propertyKey] as Partial<VovkHandlerSchema>),
-          path,
-          httpMethod,
-        },
-      };
-
-      const originalMethod = controller[propertyKey] as ((...args: KnownAny) => KnownAny) & {
-        _controller: VovkController;
-        _sourceMethod?: (...args: KnownAny) => KnownAny;
-      };
-
-      originalMethod._controller = controller;
-      originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-
-      methods[path] = controller[propertyKey] as RouteHandler;
-      methods[path]._options = options;
-    };
-
-    function decoratorCreator(givenPath = '', options?: DecoratorOptions) {
-      const path = trimPath(givenPath);
-
-      function decorator(givenTarget: KnownAny, propertyKey: string) {
-        const target = givenTarget as VovkController;
-        assignSchema(target, propertyKey, path, options);
-      }
-
-      return decorator;
-    }
-
-    const auto = (options?: DecoratorOptions) => {
-      function decorator(givenTarget: KnownAny, propertyKey: string) {
-        const controller = givenTarget as VovkController;
-        const methods: Record<string, RouteHandler> = vovkApp.routes[httpMethod].get(controller) ?? {};
-        vovkApp.routes[httpMethod].set(controller, methods);
-
-        controller._handlers = {
-          ...controller._handlers,
-          [propertyKey]: {
-            ...(controller._handlers ?? {})[propertyKey],
-            httpMethod,
-          },
-        };
-
-        assignSchema(controller, propertyKey, toKebabCase(propertyKey), options);
-      }
-
-      return decorator;
-    };
-
-    const enhancedDecoratorCreator = decoratorCreator as {
-      (...args: Parameters<typeof decoratorCreator>): ReturnType<typeof decoratorCreator>;
-      auto: typeof auto;
-    };
-
-    enhancedDecoratorCreator.auto = auto;
-
-    return enhancedDecoratorCreator;
-  };
-
-  const prefix = (givenPath = '') => {
-    const path = trimPath(givenPath);
-
-    return (givenTarget: KnownAny) => {
-      const controller = givenTarget as VovkController;
-      controller._prefix = path;
-
-      return givenTarget;
-    };
-  };
-
-  const initVovk = (options: {
-    segmentName?: string;
-    controllers: Record<string, StaticClass>;
-    exposeValidation?: boolean;
-    emitSchema?: boolean;
-    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
-  }) => {
-    for (const [controllerName, controller] of Object.entries(options.controllers) as [string, VovkController][]) {
-      controller._controllerName = controllerName;
-      controller._activated = true;
-      controller._onError = options?.onError;
-    }
-
-    async function GET_DEV(req: NextRequest, data: { params: Promise<Record<string, string[]>> }) {
-      const params = await data.params;
-      if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
-        // Wait for schema to be set (it can be set after decorators are called with another setTimeout)
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const schema = getSchema(options);
-        return vovkApp.respond(200, { schema });
-      }
-      return vovkApp.GET(req, data);
-    }
-
-    return {
-      GET: process.env.NODE_ENV === 'development' ? GET_DEV : vovkApp.GET,
-      POST: vovkApp.POST,
-      PUT: vovkApp.PUT,
-      PATCH: vovkApp.PATCH,
-      DELETE: vovkApp.DELETE,
-      HEAD: vovkApp.HEAD,
-      OPTIONS: vovkApp.OPTIONS,
-    };
-  };
-
-  return {
-    get: createHTTPDecorator(HttpMethod.GET),
-    post: createHTTPDecorator(HttpMethod.POST),
-    put: createHTTPDecorator(HttpMethod.PUT),
-    patch: createHTTPDecorator(HttpMethod.PATCH),
-    del: createHTTPDecorator(HttpMethod.DELETE),
-    head: createHTTPDecorator(HttpMethod.HEAD),
-    options: createHTTPDecorator(HttpMethod.OPTIONS),
-    prefix,
-    initVovk,
-  };
-}

package/src/index.ts

@@ -1,71 +0,0 @@
-import { createVovkApp } from './createVovkApp';
-import {
-  HttpStatus as HttpStatus,
-  HttpMethod as HttpMethod,
-  type KnownAny,
-  type VovkErrorResponse,
-  type VovkRequest,
-  type VovkBody,
-  type VovkQuery,
-  type VovkParams,
-  type VovkReturnType,
-  type VovkYieldType,
-  type VovkControllerBody,
-  type VovkControllerQuery,
-  type VovkControllerParams,
-  type VovkControllerYieldType,
-  type VovkSchema,
-  type VovkControllerSchema,
-  type VovkHandlerSchema,
-} from './types';
-import {
-  type VovkClient,
-  type VovkClientOptions,
-  type VovkClientFetcher,
-  type VovkDefaultFetcherOptions,
-  type VovkValidateOnClient,
-  type VovkStreamAsyncIterable,
-  createRPC,
-} from './client';
-import { openapi } from './openapi';
-import { HttpException } from './HttpException';
-import { createDecorator } from './createDecorator';
-import { StreamJSONResponse } from './StreamJSONResponse';
-import { generateStaticAPI } from './utils/generateStaticAPI';
-import { setHandlerValidation } from './utils/setHandlerValidation';
-
-export {
-  type KnownAny,
-  type VovkClient,
-  type VovkClientFetcher,
-  type VovkDefaultFetcherOptions,
-  type VovkStreamAsyncIterable,
-  type VovkValidateOnClient,
-  type VovkSchema,
-  type VovkErrorResponse,
-  type VovkRequest,
-  type VovkControllerBody,
-  type VovkControllerQuery,
-  type VovkControllerParams,
-  type VovkControllerYieldType,
-  type VovkBody,
-  type VovkQuery,
-  type VovkParams,
-  type VovkYieldType,
-  type VovkReturnType,
-  type VovkClientOptions,
-  type VovkControllerSchema,
-  type VovkHandlerSchema,
-  StreamJSONResponse,
-  HttpException,
-  HttpStatus,
-  HttpMethod,
-  createVovkApp,
-  createDecorator,
-  createRPC,
-  generateStaticAPI,
-  openapi,
-  setHandlerValidation,
-};
-
-export const { get, post, put, patch, del, head, options, prefix, initVovk } = createVovkApp();

package/src/openapi/fromSchema.ts

@@ -1,33 +0,0 @@
-import type { OpenAPIObject, PathsObject } from 'openapi3-ts/oas31';
-import type { HttpMethod, VovkSchema } from '../types';
-
-export function fromSchema(
-  apiRoot: string,
-  vovkSchema: Record<string, VovkSchema>,
-  extendWith?: Partial<OpenAPIObject>
-): OpenAPIObject {
-  const paths: PathsObject = {};
-
-  for (const [segmentName, schema] of Object.entries(vovkSchema)) {
-    for (const c of Object.values(schema.controllers)) {
-      for (const h of Object.values(c.handlers)) {
-        if (h.openapi) {
-          const path =
-            '/' + [apiRoot.replace(/^\/+|\/+$/g, ''), segmentName, c.prefix, h.path].filter(Boolean).join('/');
-          paths[path] = paths[path] ?? {};
-          paths[path][h.httpMethod.toLowerCase() as Lowercase<HttpMethod>] = { ...h.openapi };
-        }
-      }
-    }
-  }
-
-  return {
-    ...extendWith,
-    openapi: '3.1.0',
-    info: extendWith?.info ?? {
-      title: 'API',
-      version: '1.0.0',
-    },
-    paths,
-  };
-}

package/src/openapi/index.ts

@@ -1 +0,0 @@
-export { openapi } from './openapi';

package/src/openapi/openapi.ts

@@ -1,85 +0,0 @@
-import type { OperationObject } from 'openapi3-ts/oas31';
-import { createDecorator } from '../createDecorator';
-import { fromSchema } from './fromSchema';
-
-type OperationObjectWithCustomProperties = OperationObject & {
-  [key in `${'x' | 'X'}-${string}`]: any;
-};
-
-type SimpleJsonSchema = {
-  type: 'object';
-  properties: Record<string, any>;
-  required?: string[];
-};
-
-const openapiDecorator = createDecorator(null, (openAPIOperationObject: OperationObjectWithCustomProperties = {}) => {
-  return (handlerSchema) => ({
-    ...handlerSchema,
-    openapi: {
-      ...handlerSchema?.openapi,
-      ...(handlerSchema?.validation?.output &&
-      'type' in handlerSchema.validation.output &&
-      'properties' in handlerSchema.validation.output
-        ? {
-            responses: {
-              200: {
-                description:
-                  'description' in handlerSchema.validation.output
-                    ? handlerSchema.validation.output.description
-                    : 'Success',
-                content: {
-                  'application/json': {
-                    schema: handlerSchema.validation.output,
-                  },
-                },
-              },
-            },
-          }
-        : {}),
-      ...(handlerSchema?.validation?.body &&
-      'type' in handlerSchema.validation.body &&
-      'properties' in handlerSchema.validation.body
-        ? {
-            requestBody: {
-              description:
-                'description' in handlerSchema.validation.body
-                  ? handlerSchema.validation.body.description
-                  : 'Request body',
-              required: true,
-              content: {
-                'application/json': {
-                  schema: handlerSchema.validation.body,
-                },
-              },
-            },
-          }
-        : {}),
-      ...(handlerSchema?.validation?.query &&
-      'type' in handlerSchema.validation.query &&
-      'properties' in handlerSchema.validation.query
-        ? {
-            parameters: Object.entries((handlerSchema.validation.query as SimpleJsonSchema).properties)
-              .filter(([, propSchema]) => propSchema.type === 'string')
-              .map(([propName, propSchema]) => ({
-                name: propName,
-                in: 'query',
-                description: propSchema.description || '',
-                required: handlerSchema.validation?.query.required
-                  ? handlerSchema.validation.query.required.includes(propName)
-                  : false,
-                schema: {
-                  type: 'string',
-                },
-              })),
-          }
-        : {}),
-      ...openAPIOperationObject,
-    },
-  });
-});
-
-export const openapi = openapiDecorator as typeof openapiDecorator & {
-  fromSchema: typeof fromSchema;
-};
-
-openapi.fromSchema = fromSchema;