@classytic/arc 1.1.0 → 2.1.3

package/dist/prisma-C3iornoK.d.mts

@@ -0,0 +1,274 @@
+import { D as CrudRepository, a as RepositoryLike, n as DataAdapter, o as SchemaMetadata, s as ValidationResult } from "./interface-e9XfSsUV.mjs";
+import { OpenApiSchemas, ParsedQuery, QueryParserInterface, RouteSchemaOptions } from "./types/index.mjs";
+import { Model } from "mongoose";
+
+//#region src/adapters/mongoose.d.ts
+/**
+ * Options for creating a Mongoose adapter
+ *
+ * @typeParam TDoc - The document type (inferred or explicit)
+ */
+/**
+ * Options for creating a Mongoose adapter
+ *
+ * @typeParam TDoc - The document type (inferred or explicit)
+ */
+interface MongooseAdapterOptions<TDoc = unknown> {
+  /** Mongoose model instance — preserves document type for type safety */
+  model: Model<TDoc>;
+  /** Repository implementing CRUD operations - accepts any repository-like object */
+  repository: CrudRepository<TDoc> | RepositoryLike;
+  /**
+   * External schema generator plugin for OpenAPI docs.
+   * When provided, replaces the built-in basic type conversion.
+   * Receives the Mongoose model and schema options, must return OpenApiSchemas.
+   *
+   * @example MongoKit integration
+   * ```typescript
+   * import { buildCrudSchemasFromModel } from '@classytic/mongokit';
+   *
+   * createMongooseAdapter({
+   *   model: JobModel,
+   *   repository: jobRepository,
+   *   schemaGenerator: (model, options) => buildCrudSchemasFromModel(model, options),
+   * });
+   * ```
+   */
+  schemaGenerator?: (model: Model<TDoc>, options?: RouteSchemaOptions) => OpenApiSchemas;
+}
+/**
+ * Mongoose data adapter with proper type safety
+ *
+ * @typeParam TDoc - The document type
+ */
+declare class MongooseAdapter<TDoc = unknown> implements DataAdapter<TDoc> {
+  readonly type: "mongoose";
+  readonly name: string;
+  readonly model: Model<TDoc>;
+  readonly repository: CrudRepository<TDoc> | RepositoryLike;
+  private readonly schemaGenerator?;
+  constructor(options: MongooseAdapterOptions<TDoc>);
+  /**
+   * Get schema metadata from Mongoose model
+   */
+  getSchemaMetadata(): SchemaMetadata;
+  /**
+   * Generate OpenAPI schemas from Mongoose model.
+   *
+   * If a `schemaGenerator` plugin was provided (e.g. MongoKit's buildCrudSchemasFromModel),
+   * it is used instead of the built-in basic conversion.
+   */
+  generateSchemas(schemaOptions?: RouteSchemaOptions): OpenApiSchemas | null;
+  /**
+   * Extract relation metadata
+   */
+  private extractRelations;
+  /**
+   * Convert Mongoose type to OpenAPI type
+   */
+  private mongooseTypeToOpenApi;
+}
+/**
+ * Create Mongoose adapter with flexible type acceptance.
+ * Accepts any repository with CRUD methods — no `as any` needed.
+ *
+ * @example
+ * ```typescript
+ * // Object form (explicit)
+ * const adapter = createMongooseAdapter({
+ *   model: ProductModel,
+ *   repository: productRepository,
+ * });
+ *
+ * // Shorthand form (2-arg) — most common path
+ * const adapter = createMongooseAdapter(ProductModel, productRepository);
+ * ```
+ */
+declare function createMongooseAdapter<TDoc = unknown>(model: Model<TDoc>, repository: CrudRepository<TDoc> | RepositoryLike): DataAdapter<TDoc>;
+declare function createMongooseAdapter<TDoc = unknown>(options: MongooseAdapterOptions<TDoc>): DataAdapter<TDoc>;
+//#endregion
+//#region src/adapters/prisma.d.ts
+/** Prisma DMMF field shape */
+interface DmmfField {
+  name: string;
+  type: string;
+  kind: string;
+  isList: boolean;
+  isRequired: boolean;
+  isUnique?: boolean;
+  isId?: boolean;
+  isGenerated?: boolean;
+  hasDefaultValue?: boolean;
+  default?: unknown;
+  documentation?: string;
+  relationName?: string;
+}
+/** Prisma DMMF enum value */
+interface DmmfEnumValue {
+  name: string;
+}
+/** Prisma DMMF enum */
+interface DmmfEnum {
+  name: string;
+  values: DmmfEnumValue[];
+}
+/** Prisma DMMF model shape */
+interface DmmfModel {
+  name: string;
+  fields: DmmfField[];
+  uniqueIndexes?: Array<{
+    fields: string[];
+  }>;
+}
+/** Prisma DMMF datamodel */
+interface DmmfDatamodel {
+  models: DmmfModel[];
+  enums?: DmmfEnum[];
+}
+/** Prisma DMMF root shape */
+interface PrismaDmmf {
+  datamodel?: DmmfDatamodel;
+}
+/** Prisma client shape */
+interface PrismaClientLike {
+  $disconnect(): Promise<void>;
+  [key: string]: unknown;
+}
+/**
+ * Options for PrismaQueryParser
+ */
+interface PrismaQueryParserOptions {
+  /** Maximum allowed limit value (default: 1000) */
+  maxLimit?: number;
+  /** Default limit for pagination (default: 20) */
+  defaultLimit?: number;
+  /** Enable soft delete filtering by default (default: true) */
+  softDeleteEnabled?: boolean;
+  /** Field name for soft delete (default: 'deletedAt') */
+  softDeleteField?: string;
+}
+/**
+ * Prisma Query Parser - Converts URL parameters to Prisma query format
+ *
+ * Translates Arc's query format to Prisma's where/orderBy/take/skip structure.
+ *
+ * @example
+ * ```typescript
+ * const parser = new PrismaQueryParser();
+ *
+ * // URL: ?status=active&price[gte]=100&sort=-createdAt&page=2&limit=10
+ * const prismaQuery = parser.toPrismaQuery(parsedQuery);
+ * // Returns:
+ * // {
+ * //   where: { status: 'active', price: { gte: 100 }, deletedAt: null },
+ * //   orderBy: { createdAt: 'desc' },
+ * //   take: 10,
+ * //   skip: 10,
+ * // }
+ * ```
+ */
+declare class PrismaQueryParser implements QueryParserInterface {
+  private readonly maxLimit;
+  private readonly defaultLimit;
+  private readonly softDeleteEnabled;
+  private readonly softDeleteField;
+  /** Map Arc operators to Prisma operators */
+  private readonly operatorMap;
+  constructor(options?: PrismaQueryParserOptions);
+  /**
+   * Parse URL query parameters (delegates to ArcQueryParser format)
+   */
+  parse(query: Record<string, unknown> | null | undefined): ParsedQuery;
+  /**
+   * Convert ParsedQuery to Prisma query options
+   */
+  toPrismaQuery(parsed: ParsedQuery, policyFilters?: Record<string, unknown>): PrismaQueryOptions;
+  /**
+   * Translate Arc/MongoDB-style filters to Prisma where clause
+   */
+  private translateFilters;
+  private parseNumber;
+  private parseSort;
+  private parseSelect;
+  private parseFilters;
+  private coerceValue;
+}
+/**
+ * Prisma query options returned by toPrismaQuery
+ */
+interface PrismaQueryOptions {
+  where?: Record<string, unknown>;
+  orderBy?: Array<Record<string, 'asc' | 'desc'>>;
+  take?: number;
+  skip?: number;
+  select?: Record<string, boolean>;
+  include?: Record<string, boolean>;
+}
+interface PrismaAdapterOptions<TModel> {
+  /** Prisma client instance */
+  client: PrismaClientLike;
+  /** Model name (e.g., 'user', 'product') */
+  modelName: string;
+  /** Repository instance implementing CRUD operations */
+  repository: CrudRepository<TModel>;
+  /** Optional: Prisma DMMF (Data Model Meta Format) for schema extraction */
+  dmmf?: PrismaDmmf;
+  /** Optional: Custom query parser (default: PrismaQueryParser) */
+  queryParser?: PrismaQueryParser;
+  /** Enable soft delete filtering (default: true) */
+  softDeleteEnabled?: boolean;
+  /** Field name for soft delete (default: 'deletedAt') */
+  softDeleteField?: string;
+}
+declare class PrismaAdapter<TModel = unknown> implements DataAdapter<TModel> {
+  readonly type: "prisma";
+  readonly name: string;
+  readonly repository: CrudRepository<TModel>;
+  readonly queryParser: PrismaQueryParser;
+  private client;
+  private modelName;
+  private dmmf?;
+  private softDeleteEnabled;
+  private softDeleteField;
+  constructor(options: PrismaAdapterOptions<TModel>);
+  /**
+   * Parse URL query parameters and convert to Prisma query options
+   */
+  parseQuery(query: Record<string, unknown>, policyFilters?: Record<string, unknown>): PrismaQueryOptions;
+  /**
+   * Apply policy filters to existing Prisma where clause
+   * Used for multi-tenant, ownership, and other security filters
+   */
+  applyPolicyFilters(where: Record<string, unknown>, policyFilters: Record<string, unknown>): Record<string, unknown>;
+  generateSchemas(options?: RouteSchemaOptions): OpenApiSchemas | null;
+  getSchemaMetadata(): SchemaMetadata | null;
+  validate(data: unknown): Promise<ValidationResult>;
+  healthCheck(): Promise<boolean>;
+  close(): Promise<void>;
+  private buildEntitySchema;
+  private buildCreateSchema;
+  private buildUpdateSchema;
+  private shouldSkipField;
+  private convertPrismaFieldToJsonSchema;
+  private convertPrismaFieldToMetadata;
+  private mapPrismaTypeToMetadataType;
+}
+/**
+ * Factory function to create Prisma adapter
+ *
+ * @example
+ * import { PrismaClient } from '@prisma/client';
+ * import { createPrismaAdapter } from '@classytic/arc';
+ *
+ * const prisma = new PrismaClient();
+ *
+ * const userAdapter = createPrismaAdapter({
+ *   client: prisma,
+ *   modelName: 'user',
+ *   repository: userRepository,
+ *   dmmf: Prisma.dmmf, // Optional: for schema generation
+ * });
+ */
+declare function createPrismaAdapter<TModel>(options: PrismaAdapterOptions<TModel>): PrismaAdapter<TModel>;
+//#endregion
+export { PrismaQueryParserOptions as a, MongooseAdapterOptions as c, PrismaQueryParser as i, createMongooseAdapter as l, PrismaAdapterOptions as n, createPrismaAdapter as o, PrismaQueryOptions as r, MongooseAdapter as s, PrismaAdapter as t };