@geekmidas/constructs 0.0.1

package/src/endpoints/EndpointBuilder.ts

@@ -0,0 +1,308 @@
+import type { Logger } from '@geekmidas/logger';
+import type { RateLimitConfig } from '@geekmidas/rate-limit';
+import type { Service } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import uniqBy from 'lodash.uniqby';
+import { ConstructType } from '../Construct';
+import { BaseFunctionBuilder } from '../functions';
+import { Endpoint, type EndpointSchemas } from './Endpoint';
+import type {
+  AuthorizeFn,
+  EndpointHandler,
+  SessionFn,
+  SuccessStatus,
+} from './Endpoint';
+
+import type { EventPublisher, MappedEvent } from '@geekmidas/events';
+import type { HttpMethod } from '../types';
+
+export class EndpointBuilder<
+  TRoute extends string,
+  TMethod extends HttpMethod,
+  TInput extends EndpointSchemas = {},
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  OutSchema extends StandardSchemaV1 | undefined = undefined,
+  TSession = unknown,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> extends BaseFunctionBuilder<
+  TInput,
+  OutSchema,
+  TServices,
+  TLogger,
+  TEventPublisher,
+  TEventPublisherServiceName
+> {
+  protected schemas: TInput = {} as TInput;
+  protected _description?: string;
+  protected _status?: SuccessStatus;
+  protected _tags?: string[];
+  _getSession: SessionFn<TServices, TLogger, TSession> = () => ({}) as TSession;
+  _authorize: AuthorizeFn<TServices, TLogger, TSession> = () => true;
+  _rateLimit?: RateLimitConfig;
+
+  constructor(
+    readonly route: TRoute,
+    readonly method: TMethod,
+  ) {
+    super(ConstructType.Endpoint);
+  }
+
+  // Internal setter for EndpointFactory to set default publisher
+  _setPublisher(
+    publisher: Service<TEventPublisherServiceName, TEventPublisher>,
+  ) {
+    this._publisher = publisher;
+  }
+
+  description(description: string): this {
+    this._description = description;
+    return this;
+  }
+
+  status(status: SuccessStatus): this {
+    this._status = status;
+    return this;
+  }
+
+  event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(
+    event: TEvent,
+  ): this {
+    this._events.push(event);
+    return this;
+  }
+
+  tags(tags: string[]): this {
+    this._tags = tags;
+    return this;
+  }
+
+  publisher<T extends EventPublisher<any>, TName extends string>(
+    publisher: Service<TName, T>,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    TInput,
+    TServices,
+    TLogger,
+    OutSchema,
+    TSession,
+    T,
+    TName
+  > {
+    this._publisher = publisher as unknown as Service<
+      TEventPublisherServiceName,
+      TEventPublisher
+    >;
+
+    return this as unknown as EndpointBuilder<
+      TRoute,
+      TMethod,
+      TInput,
+      TServices,
+      TLogger,
+      OutSchema,
+      TSession,
+      T,
+      TName
+    >;
+  }
+
+  body<T extends StandardSchemaV1>(
+    schema: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    Omit<TInput, 'body'> & { body: T },
+    TServices,
+    TLogger,
+    OutSchema,
+    TSession,
+    TEventPublisher
+  > {
+    this.schemas.body = schema as unknown as T;
+    // @ts-ignore
+    return this;
+  }
+
+  search<T extends StandardSchemaV1>(
+    schema: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    Omit<TInput, 'query'> & { query: T },
+    TServices,
+    TLogger,
+    OutSchema,
+    TSession,
+    TEventPublisher
+  > {
+    this.schemas.query = schema as unknown as T;
+    // @ts-ignore
+    return this;
+  }
+
+  query<T extends StandardSchemaV1>(
+    schema: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    Omit<TInput, 'query'> & { query: T },
+    TServices,
+    TLogger,
+    OutSchema,
+    TSession,
+    TEventPublisher
+  > {
+    return this.search(schema);
+  }
+
+  params<T extends StandardSchemaV1>(
+    schema: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    Omit<TInput, 'params'> & { params: T },
+    TServices,
+    TLogger,
+    OutSchema,
+    TSession,
+    TEventPublisher
+  > {
+    this.schemas.params = schema as unknown as T;
+    // @ts-ignore
+    return this;
+  }
+
+  rateLimit(config: RateLimitConfig): this {
+    this._rateLimit = config;
+    return this;
+  }
+
+  services<T extends Service[]>(
+    services: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    TInput,
+    [...TServices, ...T],
+    TLogger,
+    OutSchema,
+    TSession,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this._services = uniqBy(
+      [...this._services, ...services],
+      (s) => s.serviceName,
+    ) as TServices;
+
+    return this as unknown as EndpointBuilder<
+      TRoute,
+      TMethod,
+      TInput,
+      [...TServices, ...T],
+      TLogger,
+      OutSchema,
+      TSession,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  logger<T extends Logger>(
+    logger: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    TInput,
+    TServices,
+    T,
+    OutSchema,
+    TSession,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this._logger = logger as unknown as TLogger;
+
+    return this as unknown as EndpointBuilder<
+      TRoute,
+      TMethod,
+      TInput,
+      TServices,
+      T,
+      OutSchema,
+      TSession,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  output<T extends StandardSchemaV1>(
+    schema: T,
+  ): EndpointBuilder<
+    TRoute,
+    TMethod,
+    TInput,
+    TServices,
+    TLogger,
+    T,
+    TSession,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this.outputSchema = schema as unknown as OutSchema;
+
+    return this as unknown as EndpointBuilder<
+      TRoute,
+      TMethod,
+      TInput,
+      TServices,
+      TLogger,
+      T,
+      TSession,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  // EndpointBuilder doesn't have a generic input method - it uses body, query, params instead
+  input(_schema: any): any {
+    throw new Error(
+      'EndpointBuilder does not support generic input. Use body(), query(), or params() instead.',
+    );
+  }
+
+  handle(
+    fn: EndpointHandler<TInput, TServices, TLogger, OutSchema, TSession>,
+  ): Endpoint<
+    TRoute,
+    TMethod,
+    TInput,
+    OutSchema,
+    TServices,
+    TLogger,
+    TSession,
+    TEventPublisher
+  > {
+    return new Endpoint({
+      fn,
+      method: this.method,
+      route: this.route,
+      description: this._description,
+      tags: this._tags,
+      input: this.schemas,
+      output: this.outputSchema,
+      services: this._services,
+      logger: this._logger,
+      timeout: this._timeout,
+      authorize: this._authorize,
+      status: this._status,
+      getSession: this._getSession,
+      rateLimit: this._rateLimit,
+      publisherService: this._publisher,
+      events: this._events,
+    });
+  }
+}

package/src/endpoints/EndpointFactory.ts

@@ -0,0 +1,329 @@
+import type { Logger } from '@geekmidas/logger';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import type { Service } from '@geekmidas/services';
+import uniqBy from 'lodash.uniqby';
+import type { AuthorizeFn, SessionFn } from './Endpoint';
+import { EndpointBuilder } from './EndpointBuilder';
+
+import type { EventPublisher, MappedEvent } from '@geekmidas/events';
+import type { HttpMethod } from '../types';
+
+const DEFAULT_LOGGER = new ConsoleLogger() as any;
+
+export class EndpointFactory<
+  TServices extends Service[] = [],
+  TBasePath extends string = '',
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> {
+  // @ts-ignore
+  private defaultServices: TServices;
+  private basePath: TBasePath = '' as TBasePath;
+  private defaultAuthorizeFn?: AuthorizeFn<TServices, TLogger, TSession>;
+  private defaultEventPublisher:
+    | Service<TEventPublisherServiceName, TEventPublisher>
+    | undefined;
+  private defaultSessionExtractor?: SessionFn<TServices, TLogger, TSession>;
+  private defaultLogger: TLogger = DEFAULT_LOGGER;
+
+  constructor({
+    basePath,
+    defaultAuthorizeFn,
+    defaultLogger,
+    defaultSessionExtractor,
+    // @ts-ignore
+    defaultServices = [] as TServices,
+    defaultEventPublisher,
+  }: EndpointFactoryOptions<
+    TServices,
+    TBasePath,
+    TLogger,
+    TSession,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > = {}) {
+    // Initialize default services
+    this.defaultServices = uniqBy(
+      defaultServices,
+      (s) => s.serviceName,
+    ) as TServices;
+
+    this.basePath = basePath || ('' as TBasePath);
+    this.defaultAuthorizeFn = defaultAuthorizeFn;
+    this.defaultLogger = defaultLogger || (DEFAULT_LOGGER as TLogger);
+    this.defaultSessionExtractor = defaultSessionExtractor;
+    this.defaultEventPublisher = defaultEventPublisher;
+  }
+
+  static joinPaths<TBasePath extends string, P extends string>(
+    path: P,
+    basePath: TBasePath = '' as TBasePath,
+  ): JoinPaths<TBasePath, P> {
+    // Handle empty cases
+    if (!basePath && !path) return '/' as JoinPaths<TBasePath, P>;
+    if (!basePath)
+      return (path.startsWith('/') ? path : '/' + path) as JoinPaths<
+        TBasePath,
+        P
+      >;
+    if (!path)
+      return (
+        basePath.startsWith('/') ? basePath : '/' + basePath
+      ) as JoinPaths<TBasePath, P>;
+
+    const base = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+    const segment = path.startsWith('/') ? path : '/' + path;
+
+    let result = base + segment;
+
+    // Ensure leading slash
+    if (!result.startsWith('/')) {
+      result = '/' + result;
+    }
+
+    // Normalize multiple slashes (except in the middle of the path where they might be intentional)
+    result = result.replace(/^\/+/g, '/');
+
+    // Remove trailing slash unless it's the root path "/"
+    if (result.length > 1 && result.endsWith('/')) {
+      result = result.slice(0, -1);
+    }
+
+    return result as JoinPaths<TBasePath, P>;
+  }
+
+  // Create a sub-router with a path prefix
+  route<TPath extends string>(
+    path: TPath,
+  ): EndpointFactory<
+    TServices,
+    JoinPaths<TBasePath, TPath>,
+    TLogger,
+    TSession,
+    TEventPublisher
+  > {
+    const newBasePath = EndpointFactory.joinPaths(path, this.basePath);
+    return new EndpointFactory({
+      defaultServices: this.defaultServices,
+      basePath: newBasePath,
+      defaultAuthorizeFn: this.defaultAuthorizeFn,
+      defaultLogger: this.defaultLogger,
+      defaultSessionExtractor: this.defaultSessionExtractor,
+      defaultEventPublisher: this.defaultEventPublisher,
+    });
+  }
+
+  // Create a new factory with authorization
+  authorize(
+    fn: AuthorizeFn<TServices, TLogger, TSession>,
+  ): EndpointFactory<TServices, TBasePath, TLogger, TSession, TEventPublisher> {
+    return new EndpointFactory({
+      defaultServices: this.defaultServices,
+      basePath: this.basePath,
+      defaultAuthorizeFn: fn,
+      defaultLogger: this.defaultLogger,
+      defaultSessionExtractor: this.defaultSessionExtractor,
+      defaultEventPublisher: this.defaultEventPublisher,
+    });
+  }
+
+  // Create a new factory with services
+  services<S extends Service[]>(
+    services: S,
+  ): EndpointFactory<
+    [...S, ...TServices],
+    TBasePath,
+    TLogger,
+    TSession,
+    TEventPublisher
+  > {
+    return new EndpointFactory<
+      [...S, ...TServices],
+      TBasePath,
+      TLogger,
+      TSession,
+      TEventPublisher
+    >({
+      defaultServices: [...services, ...this.defaultServices],
+      basePath: this.basePath,
+      defaultAuthorizeFn: this.defaultAuthorizeFn,
+      defaultLogger: this.defaultLogger,
+      defaultSessionExtractor: this.defaultSessionExtractor,
+      defaultEventPublisher: this.defaultEventPublisher,
+    });
+  }
+
+  logger<L extends Logger>(
+    logger: L,
+  ): EndpointFactory<TServices, TBasePath, L, TSession> {
+    return new EndpointFactory<TServices, TBasePath, L, TSession>({
+      defaultServices: this.defaultServices,
+      basePath: this.basePath,
+      defaultAuthorizeFn: this.defaultAuthorizeFn,
+      defaultLogger: logger,
+      defaultSessionExtractor: this.defaultSessionExtractor,
+    } as EndpointFactoryOptions<TServices, TBasePath, L, TSession>);
+  }
+
+  publisher<
+    T extends EventPublisher<any>,
+    TServiceName extends string = string,
+  >(
+    publisher: Service<TServiceName, T>,
+  ): EndpointFactory<TServices, TBasePath, TLogger, TSession, T> {
+    return new EndpointFactory<TServices, TBasePath, TLogger, TSession, T>({
+      defaultServices: this.defaultServices,
+      basePath: this.basePath,
+      defaultAuthorizeFn: this.defaultAuthorizeFn,
+      defaultLogger: this.defaultLogger,
+      defaultSessionExtractor: this.defaultSessionExtractor,
+      defaultEventPublisher: publisher,
+    });
+  }
+
+  session<T>(session: SessionFn<TServices, TLogger, T>) {
+    return new EndpointFactory<TServices, TBasePath, TLogger, T>({
+      defaultServices: this.defaultServices,
+      basePath: this.basePath,
+      // @ts-ignore
+      defaultAuthorizeFn: this.defaultAuthorizeFn,
+      defaultLogger: this.defaultLogger,
+      defaultSessionExtractor: session,
+      defaultEventPublisher: this.defaultEventPublisher as any,
+    });
+  }
+
+  private createBuilder<TMethod extends HttpMethod, TPath extends string>(
+    method: TMethod,
+    path: TPath,
+  ): EndpointBuilder<
+    JoinPaths<TBasePath, TPath>,
+    TMethod,
+    {},
+    TServices,
+    TLogger,
+    undefined,
+    TSession,
+    TEventPublisher
+  > {
+    const fullPath = EndpointFactory.joinPaths(path, this.basePath);
+    const builder = new EndpointBuilder<
+      JoinPaths<TBasePath, TPath>,
+      TMethod,
+      {},
+      TServices,
+      TLogger,
+      undefined,
+      TSession,
+      TEventPublisher
+    >(fullPath, method);
+
+    if (this.defaultAuthorizeFn) {
+      // @ts-ignore
+      builder._authorize = this.defaultAuthorizeFn;
+    }
+    if (this.defaultServices.length) {
+      builder._services = this.defaultServices as TServices;
+    }
+
+    if (this.defaultLogger) {
+      builder._logger = this.defaultLogger as TLogger;
+    }
+
+    if (this.defaultSessionExtractor) {
+      builder._getSession = this.defaultSessionExtractor as SessionFn<
+        TServices,
+        TLogger,
+        TSession
+      >;
+    }
+
+    if (this.defaultEventPublisher) {
+      builder._setPublisher(this.defaultEventPublisher);
+    }
+
+    return builder as unknown as EndpointBuilder<
+      JoinPaths<TBasePath, TPath>,
+      TMethod,
+      {},
+      TServices,
+      TLogger,
+      undefined,
+      TSession,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  post<TPath extends string>(path: TPath) {
+    return this.createBuilder('POST', path);
+  }
+
+  get<TPath extends string>(path: TPath) {
+    return this.createBuilder('GET', path);
+  }
+
+  put<TPath extends string>(path: TPath) {
+    return this.createBuilder('PUT', path);
+  }
+
+  delete<TPath extends string>(path: TPath) {
+    return this.createBuilder('DELETE', path);
+  }
+
+  patch<TPath extends string>(path: TPath) {
+    return this.createBuilder('PATCH', path);
+  }
+
+  options<TPath extends string>(path: TPath) {
+    return this.createBuilder('OPTIONS', path);
+  }
+}
+
+export type RemoveTrailingSlash<T extends string> = T extends `${infer Rest}/`
+  ? Rest extends ''
+    ? T // Keep "/" as is
+    : Rest
+  : T;
+
+export type JoinPaths<
+  TBasePath extends string,
+  TPath extends string,
+> = RemoveTrailingSlash<
+  TBasePath extends ''
+    ? TPath
+    : TPath extends ''
+      ? TBasePath
+      : TBasePath extends '/'
+        ? TPath extends `/${string}`
+          ? TPath
+          : `/${TPath}`
+        : TBasePath extends `${infer Base}/`
+          ? TPath extends `/${infer Rest}`
+            ? `${Base}/${Rest}`
+            : `${Base}/${TPath}`
+          : TPath extends `/${infer Rest}`
+            ? `${TBasePath}/${Rest}`
+            : `${TBasePath}/${TPath}`
+>;
+
+export interface EndpointFactoryOptions<
+  TServices extends Service[] = [],
+  TBasePath extends string = '',
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> {
+  defaultServices?: TServices;
+  basePath?: TBasePath;
+  defaultAuthorizeFn?: AuthorizeFn<TServices, TLogger, TSession>;
+  defaultLogger?: TLogger;
+  defaultSessionExtractor?: SessionFn<TServices, TLogger, TSession>;
+  defaultEventPublisher?: Service<TEventPublisherServiceName, TEventPublisher>;
+  defaultEvents?: MappedEvent<TEventPublisher, undefined>[];
+}
+
+export const e = new EndpointFactory();