@classytic/arc 2.11.4 → 2.13.1

package/dist/index-Rg8axYPz.d.mts

@@ -1,370 +0,0 @@
-import { $ as OpenApiSchemas, Dn as AdapterRepositoryInput, Mn as RepositoryLike, Nn as SchemaMetadata, On as AdapterSchemaContext, Pn as ValidationResult, S as QueryParserInterface, b as ParsedQuery, ft as RouteSchemaOptions, kn as DataAdapter } from "./index-CXXRbnf8.mjs";
-import { StandardRepo } from "@classytic/repo-core/repository";
-import { Model } from "mongoose";
-
-//#region src/adapters/drizzle.d.ts
-/**
- * Minimum shape arc needs from a Drizzle column. Every SQLite, PG, and MySQL
- * column in `drizzle-orm` exposes these via `getTableColumns(table)`. Held
- * structurally so arc doesn't depend on `drizzle-orm` types.
- */
-interface DrizzleColumnLike {
-  columnType?: string;
-  dataType?: "number" | "string" | "date" | "boolean" | "json" | "buffer" | "bigint" | "custom";
-  notNull?: boolean;
-  hasDefault?: boolean;
-  primary?: boolean;
-  enumValues?: readonly string[];
-  length?: number;
-  name?: string;
-}
-/**
- * Structural Drizzle table — only requires `[Symbol.for('drizzle:Columns')]`,
- * which every Drizzle table exposes. Matches `drizzle-orm`'s `Table` at
- * runtime without importing it at compile time.
- */
-type DrizzleTableLike = Record<symbol, Record<string, DrizzleColumnLike>> & {
-  [key: string]: unknown;
-};
-interface DrizzleAdapterOptions<TDoc = unknown> {
-  /** Drizzle table — used for schema introspection. */
-  table: DrizzleTableLike;
-  /** Repository implementing the repo-core contract. */
-  repository: RepositoryLike<TDoc>;
-  /**
-   * External schema generator. When provided, replaces the built-in
-   * type-only conversion. Wire it to your kit's `buildCrudSchemasFromTable`
-   * (sqlitekit, pgkit, ...) to get the full CRUD schemas — strict
-   * additional-property control, field-rule application, param-type
-   * narrowing from primary-key columns, etc.
-   */
-  schemaGenerator?: (table: DrizzleTableLike, options?: RouteSchemaOptions, context?: AdapterSchemaContext) => OpenApiSchemas | Record<string, unknown>;
-  /** Optional name — defaults to "DrizzleAdapter". */
-  name?: string;
-}
-declare class DrizzleAdapter<TDoc = unknown> implements DataAdapter<TDoc> {
-  readonly type: "drizzle";
-  readonly name: string;
-  readonly table: DrizzleTableLike;
-  readonly repository: RepositoryLike<TDoc>;
-  private readonly schemaGenerator?;
-  constructor(options: DrizzleAdapterOptions<TDoc>);
-  /**
-   * Introspect Drizzle columns into arc's schema metadata shape.
-   */
-  getSchemaMetadata(): SchemaMetadata;
-  /**
-   * Generate OpenAPI schemas. Delegates to the user-provided
-   * `schemaGenerator` when available (strongly recommended — that's where
-   * field rules, omit lists, and param-type narrowing live). The built-in
-   * fallback emits a permissive entity + CRUD body shape so routes still
-   * register when no generator is provided.
-   *
-   * After the kit generator runs, arc merges constraint-style field rules
-   * (`minLength`, `maxLength`, `min`, `max`, `pattern`, `enum`, `description`)
-   * into the resulting property schemas so sqlitekit / pgkit behave
-   * identically to mongoose here — rule-driven AJV constraints apply
-   * regardless of backend.
-   */
-  generateSchemas(schemaOptions?: RouteSchemaOptions, context?: AdapterSchemaContext): OpenApiSchemas | Record<string, unknown> | null;
-  healthCheck(): Promise<boolean>;
-}
-/**
- * Factory — preferred construction style for symmetry with
- * `createMongooseAdapter` / `createPrismaAdapter`.
- */
-declare function createDrizzleAdapter<TDoc = unknown>(options: DrizzleAdapterOptions<TDoc>): DrizzleAdapter<TDoc>;
-//#endregion
-//#region src/adapters/mongoose.d.ts
-/**
- * Options for creating a Mongoose adapter.
- * TDoc is auto-inferred from the Mongoose model — no explicit type needed.
- *
- * @typeParam TDoc - Inferred from `model: Model<TDoc>`
- */
-interface MongooseAdapterOptions<TDoc = unknown> {
-  /** Mongoose model instance — preserves document type for type safety */
-  model: Model<TDoc>;
-  /**
-   * Repository implementing CRUD operations.
-   *
-   * Typed as `AdapterRepositoryInput<TDoc>` (permissive structural shape)
-   * so kit-native repositories like mongokit's `Repository<TDoc>` plug in
-   * directly. See `AdapterRepositoryInput` JSDoc for why the wider input
-   * exists at the boundary while arc internals keep the strict
-   * `RepositoryLike` view.
-   */
-  repository: AdapterRepositoryInput<TDoc>;
-  /**
-   * 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.
-   *
-   * **Model type is intentionally `Model<unknown>`, not `Model<TDoc>`**:
-   * schema generators introspect `.schema.paths` — they read metadata, not
-   * document types. Typing as `Model<TDoc>` forced every mongokit host to
-   * cast `m as unknown as Model<unknown>` when handing the model to
-   * `buildCrudSchemasFromModel` (which is typed `Model<unknown>`), because
-   * `Model<T>` is invariant in T. Widening here at the callback boundary
-   * trades one documented internal cast for zero host-side casts.
-   *
-   * @example MongoKit integration — direct pass-through, no casts
-   * ```typescript
-   * import { buildCrudSchemasFromModel } from '@classytic/mongokit';
-   *
-   * createMongooseAdapter({
-   *   model: JobModel,
-   *   repository: jobRepository,
-   *   schemaGenerator: buildCrudSchemasFromModel,
-   * });
-   * ```
-   */
-  schemaGenerator?: (model: Model<unknown>, options?: RouteSchemaOptions, context?: AdapterSchemaContext) => OpenApiSchemas | Record<string, unknown>;
-}
-/**
- * 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: RepositoryLike<TDoc>;
-  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, context?: AdapterSchemaContext): OpenApiSchemas | Record<string, unknown> | 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.
- *
- * **Type parameter (v2.11):** `TDoc` is UNCONSTRAINED. An earlier v2.11
- * revision added `TDoc extends AnyRecord` to surface errors at the
- * adapter call site, but Mongoose's own document types
- * (`HydratedDocument<T>`, `T & Document`) don't carry an index signature
- * — so the constraint fired on the exact Mongoose idioms this factory
- * is designed to accept. Hosts were casting with
- * `as RepositoryLike<Record<string, unknown>>` at every call just to
- * silence it. The constraint now lives exclusively on `BaseController`
- * where it's load-bearing for mixin composition; `defineResource`
- * widens once internally so every other layer stays permissive.
- *
- * @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: AdapterRepositoryInput<TDoc>): 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: StandardRepo<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: StandardRepo<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, DrizzleAdapterOptions as d, createDrizzleAdapter as f, PrismaQueryParser as i, createMongooseAdapter as l, PrismaAdapterOptions as n, createPrismaAdapter as o, PrismaQueryOptions as r, MongooseAdapter as s, PrismaAdapter as t, DrizzleAdapter as u };