arkos 1.4.9-beta → 1.4.10-beta

package/dist/cjs/utils/cli/utils/static-types-generator.js

@@ -1,558 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const promises_1 = __importDefault(require("fs/promises"));
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
-const sheu_1 = __importDefault(require("../../sheu"));
-const change_case_helpers_1 = require("../../helpers/change-case.helpers");
-const prisma_schema_parser_1 = __importDefault(require("../../prisma/prisma-schema-parser"));
-class StaticTypesGenerator {
-    constructor() {
-        this.packageName = "@arkosjs/types";
-        this.outputDir = path_1.default.resolve(process.cwd(), `node_modules/${this.packageName}`);
-    }
-    async generate() {
-        try {
-            await this.generatePrismaClient();
-            await this.ensureOutputDirectory();
-            await this.generateTypeDeclarations();
-            await this.generatePackageJson();
-            sheu_1.default.done("Types for @prisma/client and base service generated successfully!");
-        }
-        catch (error) {
-            sheu_1.default.error("Failed to generate static types:");
-            console.log(error);
-            throw error;
-        }
-    }
-    async generatePrismaClient() {
-        return new Promise((resolve, reject) => {
-            try {
-                (0, child_process_1.execSync)("npx prisma generate", { stdio: "inherit" });
-                resolve();
-            }
-            catch (error) {
-                reject(new Error(`Prisma generation failed: ${error}`));
-            }
-        });
-    }
-    async ensureOutputDirectory() {
-        await promises_1.default.mkdir(this.outputDir, { recursive: true });
-    }
-    generateDeclarationContent() {
-        return `import { ServiceBaseContext } from "arkos/services";
-import { Prisma, PrismaClient } from "@prisma/client"
-
-export interface PrismaField {
-  name: string;
-  type: string;
-  isOptional: boolean;
-  isArray: boolean;
-  foreignKeyField?: string;
-  foreignReferenceField?: string;
-  isRelation: boolean;
-  defaultValue?: any;
-  isId?: boolean;
-  isUnique?: boolean;
-  attributes: string[];
-}
-
-
-export declare type ModelsGetPayload<T extends Record<string, any>> = {
-${prisma_schema_parser_1.default.models
-            .map((model) => `  "${(0, change_case_helpers_1.kebabCase)(model.name)}": {
-      Delegate: Prisma.${model.name}Delegate,
-      GetPayload: Prisma.${model.name}GetPayload<T>,
-      FindManyArgs: Prisma.${model.name}FindManyArgs,
-      FindFirstArgs: Prisma.${model.name}FindFirstArgs,
-      CreateArgs: Prisma.${model.name}CreateArgs,
-      CreateManyArgs: Prisma.${model.name}CreateManyArgs,
-      UpdateArgs: Prisma.${model.name}UpdateArgs,
-      UpdateManyArgs: Prisma.${model.name}UpdateManyArgs,
-      DeleteArgs: Prisma.${model.name}DeleteArgs,
-      DeleteManyArgs: Prisma.${model.name}DeleteManyArgs,
-      CountArgs: Prisma.${model.name}CountArgs
-  }`)
-            .join(",\n")}
-}
-
-export type ExtractFilters<T> = T extends { where?: infer W; [x: string]: any } ? W : any;
-export type ExtractQueryOptions<T, K extends keyof T = never> = Omit<T, K>;
-export type ExtractData<T> = T extends { data: infer D; [x: string]: any } ? D : any;
-
-
-/**
- * Base service class for handling CRUD operations on a specific model.
- * This class provides standard implementation of data operations that can be extended
- *
- * by model-specific service classes.
- *
- * @class BaseService
- *
- * @usage
- *
- * **Example:** creating a simple service
- *
- * \`\`\`ts
- * import { BaseService } from "arkos/services"
- *
- * export class UserService extends BaseService<"user"> {}
- *
- * const userService = new UserService("user")
- * \`\`\`
- *
- * **Example:** accessing request context in hooks
- *
- * \`\`\`
- *
- * @see {@link https://www.arkosjs.com/docs/api-reference/the-base-service-class}
- * @see {@link https://www.arkosjs.com/docs/guide/accessing-request-context-in-services}
- *
- */
-export declare class BaseService<
-    TModelName extends keyof ModelsGetPayload<any>
-> {
-    modelName: TModelName;
-    relationFields: {
-        singular: PrismaField[] | undefined;
-        list: PrismaField[] | undefined;
-    };
-    prisma: PrismaClient;
-    
-    constructor(modelName: TModelName);
-    
-    /**
-     * Creates a single record in the database.
-     *
-     * @template TOptions - The query options type extending query options excluding 'data'
-     * @param {ExtractData} data - The data for creating the record
-     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload>} The created record
-     *
-     * @example
-     * \`\`\`ts
-     * const user = await userService.createOne({
-     *   name: "John Doe",
-     *   email: "john@example.com"
-     * });
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With query options
-     * const user = await userService.createOne(
-     *   { name: "John Doe", email: "john@example.com" },
-     *   { include: { posts: true } }
-     * );
-     * \`\`\`
-     */
-    createOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['CreateArgs'], 'data'>>(
-        data: ExtractData<ModelsGetPayload<any>[TModelName]['CreateArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;
-
-    /**
-     * Creates multiple records in the database.
-     *
-     * @template TOptions - The query options type extending query options excluding 'data'
-     * @param {ExtractData} data - Array of data objects or object with data array
-     * @param {TOptions} [queryOptions] - Optional Prisma query options
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<Array>} Array of created records
-     *
-     * @example
-     * \`\`\`ts
-     * const users = await userService.createMany([
-     *   { name: "John Doe", email: "john@example.com" },
-     *   { name: "Jane Smith", email: "jane@example.com" }
-     * ]);
-     * \`\`\`
-     */
-    createMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['CreateManyArgs'], 'data'>>(
-        data: ExtractData<ModelsGetPayload<any>[TModelName]['CreateManyArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'][]>;
-
-    /**
-     * Counts records matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {ExtractFilters} [filters] - Optional where conditions to filter records
-     * @param {TOptions} [queryOptions] - Optional Prisma query options
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<number>} The count of matching records
-     *
-     * @example
-     * \`\`\`ts
-     * const totalUsers = await userService.count();
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * const activeUsers = await userService.count({
-     *   status: "active"
-     * });
-     * \`\`\`
-     */  
-    count<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['CountArgs'], 'where'>>(
-        filters?: ExtractFilters<ModelsGetPayload<any>[TModelName]['CountArgs']>, 
-        queryOptions?: TOptions,
-        context?: ServiceBaseContext
-    ): Promise<number>;
-
-    /**
-     * Finds multiple records matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {ExtractFilters} [filters] - Optional where conditions to filter records
-     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, orderBy, skip, take, etc.)
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<Array>} Array of matching records
-     *
-     * @example
-     * \`\`\`ts
-     * const users = await userService.findMany({
-     *   status: "active"
-     * });
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With pagination and ordering
-     * const users = await userService.findMany(
-     *   { status: "active" },
-     *   { orderBy: { createdAt: "desc" }, take: 10, skip: 0 }
-     * );
-     * \`\`\`
-     */
-    findMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['FindManyArgs'], 'where'>>(
-        filters?: ExtractFilters<ModelsGetPayload<any>[TModelName]['FindManyArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'][]>;
-
-    /**
-     * Finds a single record by its ID.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {string | number} id - The unique identifier of the record
-     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload | null>} The matching record or null if not found
-     *
-     * @example
-     * \`\`\`ts
-     * const user = await userService.findById("user-123");
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With relations
-     * const user = await userService.findById(
-     *   "user-123",
-     *   { include: { posts: true, profile: true } }
-     * );
-     * \`\`\`
-     */
-    findById<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['FindFirstArgs'], 'where'>>(
-        id: string | number, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'] | null>;
-
-    /**
-     * Updates a single record matching the specified id.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where' and 'data'
-     * @param {string | number} id - The unique identifier of the record
-     * @param {ExtractData} data - The data to update
-     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload>} The updated record
-     *
-     * @example
-     * \`\`\`ts
-     * const updatedUser = await userService.updateById(
-     *   "user-123",
-     *   { name: "John Updated" }
-     * );
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With relations
-     * const updatedUser = await userService.updateById(
-     *   "user-123",
-     *   { name: "John Updated" },
-     *   { include: { posts: true } }
-     * );
-     * \`\`\`
-     */
-    updateById<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateArgs'], 'where' | 'data'>>(
-        id: string | number,
-        data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;
-
-    /**
-     * Deletes a single record matching the specified id.
-     *
-     * @param {string | number} id - The unique identifier of the record
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload>} The deleted record
-     *
-     * @example
-     * \`\`\`ts
-     * const deletedUser = await userService.deleteById("user-123");
-     * \`\`\`
-     */
-    deleteById(
-        id: string | number,
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<any>[TModelName]['GetPayload']>;
-
-    /**
-     * Finds the first record matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {ExtractFilters} filters - Where conditions to filter records
-     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, orderBy, etc.)
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload | null>} The first matching record or null if not found
-     *
-     * @example
-     * \`\`\`ts
-     * const user = await userService.findOne({
-     *   email: "john@example.com"
-     * });
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With relations and ordering
-     * const latestPost = await postService.findOne(
-     *   { published: true },
-     *   { include: { author: true }, orderBy: { createdAt: "desc" } }
-     * );
-     * \`\`\`
-     */
-    findOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['FindFirstArgs'], 'where'>>(
-        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['FindManyArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'] | null>;
-
-    /**
-     * Updates a single record matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where' and 'data'
-     * @param {ExtractFilters} filters - Where conditions to identify the record to update
-     * @param {ExtractData} data - The data to update
-     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload>} The updated record
-     *
-     * @example
-     * \`\`\`ts
-     * const updatedUser = await userService.updateOne(
-     *   { id: "user-123" },
-     *   { name: "John Updated" }
-     * );
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With relations
-     * const updatedUser = await userService.updateOne(
-     *   { id: "user-123" },
-     *   { name: "John Updated" },
-     *   { include: { posts: true } }
-     * );
-     * \`\`\`
-     */
-    updateOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateArgs'], 'where' | 'data'>>(
-        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['UpdateArgs']>, 
-        data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;
-
-    /**
-     * Updates multiple records matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where' and 'data'
-     * @param {ExtractFilters} filters - Where conditions to identify records to update
-     * @param {ExtractData} data - The data to update
-     * @param {TOptions} [queryOptions] - Optional Prisma query options
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<{ count: number }>} Object containing count of updated records
-     *
-     * @example
-     * \`\`\`ts
-     * const result = await userService.updateMany(
-     *   { status: "pending" },
-     *   { status: "active" }
-     * );
-     * console.log(result.count); // Number of updated records
-     * \`\`\`
-     */
-    updateMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateManyArgs'], 'where' | 'data'>>(
-        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['UpdateManyArgs']>, 
-        data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateManyArgs']>, 
-        queryOptions?: TOptions, 
-        context?: ServiceBaseContext
-    ): Promise<{ count: number }>;
-
-    /**
-     * Deletes a single record matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {ExtractFilters} filters - Where conditions to identify the record to delete
-     * @param {TOptions} [queryOptions] - Optional Prisma query options
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<ModelsGetPayload>} The deleted record
-     *
-     * @example
-     * \`\`\`ts
-     * const deletedUser = await userService.deleteOne({
-     *   id: "user-123"
-     * });
-     * \`\`\`
-     */
-    deleteOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['DeleteArgs'], 'where'>>(
-        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['DeleteArgs']>, 
-        queryOptions?: TOptions,
-        context?: ServiceBaseContext
-    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;
-
-    /**
-     * Deletes multiple records matching the specified filters.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {ExtractFilters} filters - Where conditions to identify records to delete
-     * @param {TOptions} [queryOptions] - Optional Prisma query options
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<{ count: number }>} Object containing count of deleted records
-     *
-     * @example
-     * \`\`\`ts
-     * const result = await userService.deleteMany({
-     *   status: "inactive"
-     * });
-     * console.log(result.count); // Number of deleted records
-     * \`\`\`
-     */
-    deleteMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['DeleteManyArgs'], 'where'>>(
-        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['DeleteManyArgs']>, 
-        queryOptions?: TOptions,
-        context?: ServiceBaseContext
-    ): Promise<{ count: number }>;
-
-    /**
-     * Performs multiple update operations in a single transaction.
-     * Each item in the data array must contain filter criteria to identify the record to update.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where' and 'data'
-     * @param {Array<UpdateOneData>} dataArray - Array of update objects, each containing filter criteria and data
-     * @param {TOptions} [queryOptions] - Optional Prisma query options applied to all updates
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<Array<ModelsGetPayload>>} Array of updated records
-     *
-     * @example
-     * \`\`\`ts
-     * const results = await userService.batchUpdate([
-     *   { where: { id: "user-1" }, data: { status: "active" } },
-     *   { where: { id: "user-2" }, data: { status: "inactive" } }
-     * ]);
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With query options for all updates
-     * const results = await userService.batchUpdate(
-     *   [
-     *     { where: { id: "user-1" }, data: { status: "active" } },
-     *     { where: { id: "user-2" }, data: { status: "inactive" } }
-     *   ],
-     *   { include: { posts: true } }
-     * );
-     * \`\`\`
-     */
-    batchUpdate<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateArgs'], 'where' | 'data'>>(
-        dataArray: Array<{
-            where: ExtractFilters<ModelsGetPayload<any>[TModelName]['UpdateArgs']>,
-            data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateArgs']>
-        }>,
-        queryOptions?: TOptions,
-        context?: ServiceBaseContext
-    ): Promise<Array<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>>;
-
-    /**
-     * Performs multiple delete operations in a single transaction.
-     *
-     * @template TOptions - The query options type extending query options excluding 'where'
-     * @param {Array<ExtractFilters>} batchFilters - Array of where conditions, each identifying a record to delete
-     * @param {TOptions} [queryOptions] - Optional Prisma query options applied to all deletes
-     * @param {ServiceBaseContext} [context] - Optional service execution context
-     * @returns {Promise<Array<ModelsGetPayload>>} Array of deleted records
-     *
-     * @example
-     * \`\`\`ts
-     * const deletedUsers = await userService.batchDelete([
-     *   { id: "user-1" },
-     *   { id: "user-2" },
-     *   { id: "user-3" }
-     * ]);
-     * \`\`\`
-     *
-     * @example
-     * \`\`\`ts
-     * // With query options
-     * const deletedUsers = await userService.batchDelete(
-     *   [
-     *     { id: "user-1" },
-     *     { id: "user-2" }
-     *   ],
-     *   { include: { posts: true } }
-     * );
-     * \`\`\`
-     */
-    batchDelete<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['DeleteArgs'], 'where'>>(
-        batchFilters: Array<ExtractFilters<ModelsGetPayload<any>[TModelName]['DeleteArgs']>>,
-        queryOptions?: TOptions,
-        context?: ServiceBaseContext
-    ): Promise<Array<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>>;
-}
-`;
-    }
-    async generateTypeDeclarations() {
-        const content = this.generateDeclarationContent();
-        const filePath = path_1.default.join(this.outputDir, "base.service.d.ts");
-        await promises_1.default.writeFile(filePath, content, { encoding: "utf8" });
-    }
-    generatePackageJsonContent() {
-        return JSON.stringify({
-            name: this.packageName,
-            version: "1.0.0",
-            types: "./base.service.d.ts",
-            exports: {
-                "./base.service": "./base.service.d.ts",
-            },
-        }, null, 2);
-    }
-    async generatePackageJson() {
-        const content = this.generatePackageJsonContent();
-        const pkgPath = path_1.default.join(this.outputDir, "package.json");
-        await promises_1.default.writeFile(pkgPath, content, { encoding: "utf8" });
-    }
-}
-const staticTypesGenerator = new StaticTypesGenerator();
-exports.default = staticTypesGenerator;
-//# sourceMappingURL=static-types-generator.js.map

package/dist/cjs/utils/cli/utils/static-types-generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static-types-generator.js","sourceRoot":"","sources":["../../../../../src/utils/cli/utils/static-types-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport { execSync } from \"child_process\";\nimport path from \"path\";\nimport sheu from \"../../sheu\";\nimport { kebabCase } from \"../../helpers/change-case.helpers\";\nimport prismaSchemaParser from \"../../prisma/prisma-schema-parser\";\n\nclass StaticTypesGenerator {\n  private readonly outputDir: string;\n  private readonly packageName = \"@arkosjs/types\";\n\n  constructor() {\n    this.outputDir = path.resolve(\n      process.cwd(),\n      `node_modules/${this.packageName}`\n    );\n  }\n\n  /**\n   * Generates all static types including Prisma types and package metadata\n   * @returns Promise<void>\n   */\n  async generate(): Promise<void> {\n    try {\n      // Step 1: Generate Prisma client types\n      await this.generatePrismaClient();\n\n      // Step 2: Ensure output directory exists\n      await this.ensureOutputDirectory();\n\n      // Step 3: Generate TypeScript declaration file\n      await this.generateTypeDeclarations();\n\n      // Step 4: Generate package.json\n      await this.generatePackageJson();\n\n      sheu.done(\n        \"Types for @prisma/client and base service generated successfully!\"\n      );\n    } catch (error) {\n      sheu.error(\"Failed to generate static types:\");\n      console.log(error);\n      throw error;\n    }\n  }\n\n  /**\n   * Executes Prisma client generation\n   */\n  private async generatePrismaClient(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      try {\n        execSync(\"npx prisma generate\", { stdio: \"inherit\" });\n        resolve();\n      } catch (error) {\n        reject(new Error(`Prisma generation failed: ${error}`));\n      }\n    });\n  }\n\n  /**\n   * Ensures the output directory exists\n   */\n  private async ensureOutputDirectory(): Promise<void> {\n    await fs.mkdir(this.outputDir, { recursive: true });\n  }\n\n  /**\n   * Generates the TypeScript declaration file content\n   */\n  private generateDeclarationContent(): string {\n    return `import { ServiceBaseContext } from \"arkos/services\";\nimport { Prisma, PrismaClient } from \"@prisma/client\"\n\nexport interface PrismaField {\n  name: string;\n  type: string;\n  isOptional: boolean;\n  isArray: boolean;\n  foreignKeyField?: string;\n  foreignReferenceField?: string;\n  isRelation: boolean;\n  defaultValue?: any;\n  isId?: boolean;\n  isUnique?: boolean;\n  attributes: string[];\n}\n\n\nexport declare type ModelsGetPayload<T extends Record<string, any>> = {\n${prismaSchemaParser.models\n  .map(\n    (model) =>\n      `  \"${kebabCase(model.name)}\": {\n      Delegate: Prisma.${model.name}Delegate,\n      GetPayload: Prisma.${model.name}GetPayload<T>,\n      FindManyArgs: Prisma.${model.name}FindManyArgs,\n      FindFirstArgs: Prisma.${model.name}FindFirstArgs,\n      CreateArgs: Prisma.${model.name}CreateArgs,\n      CreateManyArgs: Prisma.${model.name}CreateManyArgs,\n      UpdateArgs: Prisma.${model.name}UpdateArgs,\n      UpdateManyArgs: Prisma.${model.name}UpdateManyArgs,\n      DeleteArgs: Prisma.${model.name}DeleteArgs,\n      DeleteManyArgs: Prisma.${model.name}DeleteManyArgs,\n      CountArgs: Prisma.${model.name}CountArgs\n  }`\n  )\n  .join(\",\\n\")}\n}\n\nexport type ExtractFilters<T> = T extends { where?: infer W; [x: string]: any } ? W : any;\nexport type ExtractQueryOptions<T, K extends keyof T = never> = Omit<T, K>;\nexport type ExtractData<T> = T extends { data: infer D; [x: string]: any } ? D : any;\n\n\n/**\n * Base service class for handling CRUD operations on a specific model.\n * This class provides standard implementation of data operations that can be extended\n *\n * by model-specific service classes.\n *\n * @class BaseService\n *\n * @usage\n *\n * **Example:** creating a simple service\n *\n * \\`\\`\\`ts\n * import { BaseService } from \"arkos/services\"\n *\n * export class UserService extends BaseService<\"user\"> {}\n *\n * const userService = new UserService(\"user\")\n * \\`\\`\\`\n *\n * **Example:** accessing request context in hooks\n *\n * \\`\\`\\`\n *\n * @see {@link https://www.arkosjs.com/docs/api-reference/the-base-service-class}\n * @see {@link https://www.arkosjs.com/docs/guide/accessing-request-context-in-services}\n *\n */\nexport declare class BaseService<\n    TModelName extends keyof ModelsGetPayload<any>\n> {\n    modelName: TModelName;\n    relationFields: {\n        singular: PrismaField[] | undefined;\n        list: PrismaField[] | undefined;\n    };\n    prisma: PrismaClient;\n    \n    constructor(modelName: TModelName);\n    \n    /**\n     * Creates a single record in the database.\n     *\n     * @template TOptions - The query options type extending query options excluding 'data'\n     * @param {ExtractData} data - The data for creating the record\n     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload>} The created record\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const user = await userService.createOne({\n     *   name: \"John Doe\",\n     *   email: \"john@example.com\"\n     * });\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With query options\n     * const user = await userService.createOne(\n     *   { name: \"John Doe\", email: \"john@example.com\" },\n     *   { include: { posts: true } }\n     * );\n     * \\`\\`\\`\n     */\n    createOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['CreateArgs'], 'data'>>(\n        data: ExtractData<ModelsGetPayload<any>[TModelName]['CreateArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;\n\n    /**\n     * Creates multiple records in the database.\n     *\n     * @template TOptions - The query options type extending query options excluding 'data'\n     * @param {ExtractData} data - Array of data objects or object with data array\n     * @param {TOptions} [queryOptions] - Optional Prisma query options\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<Array>} Array of created records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const users = await userService.createMany([\n     *   { name: \"John Doe\", email: \"john@example.com\" },\n     *   { name: \"Jane Smith\", email: \"jane@example.com\" }\n     * ]);\n     * \\`\\`\\`\n     */\n    createMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['CreateManyArgs'], 'data'>>(\n        data: ExtractData<ModelsGetPayload<any>[TModelName]['CreateManyArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'][]>;\n\n    /**\n     * Counts records matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {ExtractFilters} [filters] - Optional where conditions to filter records\n     * @param {TOptions} [queryOptions] - Optional Prisma query options\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<number>} The count of matching records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const totalUsers = await userService.count();\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const activeUsers = await userService.count({\n     *   status: \"active\"\n     * });\n     * \\`\\`\\`\n     */  \n    count<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['CountArgs'], 'where'>>(\n        filters?: ExtractFilters<ModelsGetPayload<any>[TModelName]['CountArgs']>, \n        queryOptions?: TOptions,\n        context?: ServiceBaseContext\n    ): Promise<number>;\n\n    /**\n     * Finds multiple records matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {ExtractFilters} [filters] - Optional where conditions to filter records\n     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, orderBy, skip, take, etc.)\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<Array>} Array of matching records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const users = await userService.findMany({\n     *   status: \"active\"\n     * });\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With pagination and ordering\n     * const users = await userService.findMany(\n     *   { status: \"active\" },\n     *   { orderBy: { createdAt: \"desc\" }, take: 10, skip: 0 }\n     * );\n     * \\`\\`\\`\n     */\n    findMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['FindManyArgs'], 'where'>>(\n        filters?: ExtractFilters<ModelsGetPayload<any>[TModelName]['FindManyArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'][]>;\n\n    /**\n     * Finds a single record by its ID.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {string | number} id - The unique identifier of the record\n     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload | null>} The matching record or null if not found\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const user = await userService.findById(\"user-123\");\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With relations\n     * const user = await userService.findById(\n     *   \"user-123\",\n     *   { include: { posts: true, profile: true } }\n     * );\n     * \\`\\`\\`\n     */\n    findById<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['FindFirstArgs'], 'where'>>(\n        id: string | number, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'] | null>;\n\n    /**\n     * Updates a single record matching the specified id.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where' and 'data'\n     * @param {string | number} id - The unique identifier of the record\n     * @param {ExtractData} data - The data to update\n     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload>} The updated record\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const updatedUser = await userService.updateById(\n     *   \"user-123\",\n     *   { name: \"John Updated\" }\n     * );\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With relations\n     * const updatedUser = await userService.updateById(\n     *   \"user-123\",\n     *   { name: \"John Updated\" },\n     *   { include: { posts: true } }\n     * );\n     * \\`\\`\\`\n     */\n    updateById<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateArgs'], 'where' | 'data'>>(\n        id: string | number,\n        data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;\n\n    /**\n     * Deletes a single record matching the specified id.\n     *\n     * @param {string | number} id - The unique identifier of the record\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload>} The deleted record\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const deletedUser = await userService.deleteById(\"user-123\");\n     * \\`\\`\\`\n     */\n    deleteById(\n        id: string | number,\n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<any>[TModelName]['GetPayload']>;\n\n    /**\n     * Finds the first record matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {ExtractFilters} filters - Where conditions to filter records\n     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, orderBy, etc.)\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload | null>} The first matching record or null if not found\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const user = await userService.findOne({\n     *   email: \"john@example.com\"\n     * });\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With relations and ordering\n     * const latestPost = await postService.findOne(\n     *   { published: true },\n     *   { include: { author: true }, orderBy: { createdAt: \"desc\" } }\n     * );\n     * \\`\\`\\`\n     */\n    findOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['FindFirstArgs'], 'where'>>(\n        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['FindManyArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload'] | null>;\n\n    /**\n     * Updates a single record matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where' and 'data'\n     * @param {ExtractFilters} filters - Where conditions to identify the record to update\n     * @param {ExtractData} data - The data to update\n     * @param {TOptions} [queryOptions] - Optional Prisma query options (select, include, etc.)\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload>} The updated record\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const updatedUser = await userService.updateOne(\n     *   { id: \"user-123\" },\n     *   { name: \"John Updated\" }\n     * );\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With relations\n     * const updatedUser = await userService.updateOne(\n     *   { id: \"user-123\" },\n     *   { name: \"John Updated\" },\n     *   { include: { posts: true } }\n     * );\n     * \\`\\`\\`\n     */\n    updateOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateArgs'], 'where' | 'data'>>(\n        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['UpdateArgs']>, \n        data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;\n\n    /**\n     * Updates multiple records matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where' and 'data'\n     * @param {ExtractFilters} filters - Where conditions to identify records to update\n     * @param {ExtractData} data - The data to update\n     * @param {TOptions} [queryOptions] - Optional Prisma query options\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<{ count: number }>} Object containing count of updated records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const result = await userService.updateMany(\n     *   { status: \"pending\" },\n     *   { status: \"active\" }\n     * );\n     * console.log(result.count); // Number of updated records\n     * \\`\\`\\`\n     */\n    updateMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateManyArgs'], 'where' | 'data'>>(\n        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['UpdateManyArgs']>, \n        data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateManyArgs']>, \n        queryOptions?: TOptions, \n        context?: ServiceBaseContext\n    ): Promise<{ count: number }>;\n\n    /**\n     * Deletes a single record matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {ExtractFilters} filters - Where conditions to identify the record to delete\n     * @param {TOptions} [queryOptions] - Optional Prisma query options\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<ModelsGetPayload>} The deleted record\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const deletedUser = await userService.deleteOne({\n     *   id: \"user-123\"\n     * });\n     * \\`\\`\\`\n     */\n    deleteOne<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['DeleteArgs'], 'where'>>(\n        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['DeleteArgs']>, \n        queryOptions?: TOptions,\n        context?: ServiceBaseContext\n    ): Promise<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>;\n\n    /**\n     * Deletes multiple records matching the specified filters.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {ExtractFilters} filters - Where conditions to identify records to delete\n     * @param {TOptions} [queryOptions] - Optional Prisma query options\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<{ count: number }>} Object containing count of deleted records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const result = await userService.deleteMany({\n     *   status: \"inactive\"\n     * });\n     * console.log(result.count); // Number of deleted records\n     * \\`\\`\\`\n     */\n    deleteMany<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['DeleteManyArgs'], 'where'>>(\n        filters: ExtractFilters<ModelsGetPayload<any>[TModelName]['DeleteManyArgs']>, \n        queryOptions?: TOptions,\n        context?: ServiceBaseContext\n    ): Promise<{ count: number }>;\n\n    /**\n     * Performs multiple update operations in a single transaction.\n     * Each item in the data array must contain filter criteria to identify the record to update.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where' and 'data'\n     * @param {Array<UpdateOneData>} dataArray - Array of update objects, each containing filter criteria and data\n     * @param {TOptions} [queryOptions] - Optional Prisma query options applied to all updates\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<Array<ModelsGetPayload>>} Array of updated records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const results = await userService.batchUpdate([\n     *   { where: { id: \"user-1\" }, data: { status: \"active\" } },\n     *   { where: { id: \"user-2\" }, data: { status: \"inactive\" } }\n     * ]);\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With query options for all updates\n     * const results = await userService.batchUpdate(\n     *   [\n     *     { where: { id: \"user-1\" }, data: { status: \"active\" } },\n     *     { where: { id: \"user-2\" }, data: { status: \"inactive\" } }\n     *   ],\n     *   { include: { posts: true } }\n     * );\n     * \\`\\`\\`\n     */\n    batchUpdate<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['UpdateArgs'], 'where' | 'data'>>(\n        dataArray: Array<{\n            where: ExtractFilters<ModelsGetPayload<any>[TModelName]['UpdateArgs']>,\n            data: ExtractData<ModelsGetPayload<any>[TModelName]['UpdateArgs']>\n        }>,\n        queryOptions?: TOptions,\n        context?: ServiceBaseContext\n    ): Promise<Array<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>>;\n\n    /**\n     * Performs multiple delete operations in a single transaction.\n     *\n     * @template TOptions - The query options type extending query options excluding 'where'\n     * @param {Array<ExtractFilters>} batchFilters - Array of where conditions, each identifying a record to delete\n     * @param {TOptions} [queryOptions] - Optional Prisma query options applied to all deletes\n     * @param {ServiceBaseContext} [context] - Optional service execution context\n     * @returns {Promise<Array<ModelsGetPayload>>} Array of deleted records\n     *\n     * @example\n     * \\`\\`\\`ts\n     * const deletedUsers = await userService.batchDelete([\n     *   { id: \"user-1\" },\n     *   { id: \"user-2\" },\n     *   { id: \"user-3\" }\n     * ]);\n     * \\`\\`\\`\n     *\n     * @example\n     * \\`\\`\\`ts\n     * // With query options\n     * const deletedUsers = await userService.batchDelete(\n     *   [\n     *     { id: \"user-1\" },\n     *     { id: \"user-2\" }\n     *   ],\n     *   { include: { posts: true } }\n     * );\n     * \\`\\`\\`\n     */\n    batchDelete<TOptions extends ExtractQueryOptions<ModelsGetPayload<any>[TModelName]['DeleteArgs'], 'where'>>(\n        batchFilters: Array<ExtractFilters<ModelsGetPayload<any>[TModelName]['DeleteArgs']>>,\n        queryOptions?: TOptions,\n        context?: ServiceBaseContext\n    ): Promise<Array<ModelsGetPayload<TOptions>[TModelName]['GetPayload']>>;\n}\n`;\n  }\n\n  /**\n   * Writes the TypeScript declaration file\n   */\n  private async generateTypeDeclarations(): Promise<void> {\n    const content = this.generateDeclarationContent();\n    const filePath = path.join(this.outputDir, \"base.service.d.ts\");\n    await fs.writeFile(filePath, content, { encoding: \"utf8\" });\n  }\n\n  /**\n   * Generates the package.json content\n   */\n  private generatePackageJsonContent(): string {\n    return JSON.stringify(\n      {\n        name: this.packageName,\n        version: \"1.0.0\",\n        types: \"./base.service.d.ts\",\n        exports: {\n          \"./base.service\": \"./base.service.d.ts\",\n        },\n      },\n      null,\n      2\n    );\n  }\n\n  /**\n   * Writes the package.json file\n   */\n  private async generatePackageJson(): Promise<void> {\n    const content = this.generatePackageJsonContent();\n    const pkgPath = path.join(this.outputDir, \"package.json\");\n    await fs.writeFile(pkgPath, content, { encoding: \"utf8\" });\n  }\n}\n\nconst staticTypesGenerator = new StaticTypesGenerator();\nexport default staticTypesGenerator;\n"]}

package/dist/esm/types/arkos-prisma-input.bak.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=arkos-prisma-input.bak.js.map

package/dist/esm/types/arkos-prisma-input.bak.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arkos-prisma-input.bak.js","sourceRoot":"","sources":["../../../src/types/arkos-prisma-input.bak.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Helper type to exclude properties from T that exist in U\n * Used internally by XOR to create mutually exclusive types\n */\ntype Without<T, U> = {\n  [P in Exclude<keyof T, keyof U>]?: never;\n};\n/**\n * XOR (Exclusive OR) type for mutually exclusive union types\n * Ensures that properties from T and U cannot be mixed together\n * @see https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types\n */\ntype XOR<T, U> = T extends object\n  ? U extends object\n    ? (Without<T, U> & U) | (Without<U, T> & T)\n    : U\n  : T;\n/**\n * Extract type from Prisma's Enumerable wrapper\n * Currently acts as identity but can be extended to handle array unwrapping\n */\n// type Unpack<T> = T extends Array<infer U> ? U : T extends (infer U)[] ? U : T;\ntype Unpack<T> = T;\n/**\n * Checks if a field is a Prisma relation field\n * A field is considered a relation if it has any of: create, connect, connectOrCreate, update, delete, disconnect\n * Handles optional fields by excluding undefined before checking\n * @template T - The type to check\n * @returns true if T is a relation field, false otherwise\n */\nexport type IsRelationField<T> =\n  Exclude<T, undefined> extends\n    | {\n        create?: { id?: any } | { id?: any }[];\n      }\n    | {\n        connect?: { id?: any } | { id?: any }[];\n      }\n    | {\n        update?: { where?: { id?: any }; data?: any };\n      }\n    | {\n        delete?: { where?: { id?: any } };\n      }\n    | {\n        disconnect?: { where?: { id?: any } };\n      }\n    ? true\n    : false;\n\n/**\n * Checks if a Prisma relation field is an array/many relation\n * Detects relations that support multiple records (one-to-many or many-to-many)\n * @template T - The relation field type\n * @returns true if it's an array relation, false otherwise\n */\nexport type IsArrayRelation<T> =\n  Exclude<T, undefined> extends { createMany?: any }\n    ? true\n    : Exclude<T, undefined> extends { deleteMany?: any }\n      ? true\n      : false;\n\n/**\n * Extracts the create data type from a Prisma relation field\n * @template T - The relation field type\n * @returns The type used in the create operation, or never if not present\n */\nexport type ExtractCreateType<T> =\n  Exclude<T, undefined> extends { create?: infer C }\n    ? C extends Array<infer U>\n      ? (U & {\n          apiAction?: \"create\";\n        })[]\n      : C & {\n          apiAction?: \"create\";\n        }\n    : never;\n\ntype ExtractConnectType<\n  T,\n  action extends \"connect\" | \"delete\" | \"udpate\" | \"disconnect\" | \"deleteMany\",\n> =\n  Exclude<T, undefined> extends { [k in action]?: infer C }\n    ? C extends Array<infer U>\n      ? (U & {\n          apiAction?: action;\n        })[]\n      : C & {\n          apiAction?: action;\n        }\n    : never;\n/**\n * Extracts and merges the update data type from a Prisma relation field\n * Combines the 'where' clause and 'data' fields into a single type\n * @template T - The relation field type\n * @returns Merged type of where & data fields, or never if not present\n */\ntype ExtractUpdateType<T> = T extends {\n  update?: infer U;\n}\n  ? U extends Array<infer Item>\n    ? Item extends {\n        where: infer W;\n        data: infer D;\n      }\n      ? ((W & D) & { apiAction?: \"update\" })[]\n      : never\n    : U extends {\n          where: infer W;\n          data: infer D;\n        }\n      ? (W & D) & { apiAction?: \"update\" }\n      : never\n  : never;\n\n/**\n * Creates a flattened union type for a single relation field\n * Combines all possible Prisma operations (create, connect, update, delete, etc.) into a discriminated union\n * Each variant includes an optional apiAction field for explicit operation specification\n * @template T - The Prisma relation field type\n */\ntype FlattenRelationField<T> =\n  /**\n   * Create Operation - Creates a new related entity\n   * Extracts the 'create' data type and recursively flattens nested relations\n   * @example { name: \"New Item\", apiAction?: \"create\" }\n   */\n  | (ExtractCreateType<T> extends never\n      ? never\n      : FlattenRelations<ExtractCreateType<T>>)\n  /**\n   * Connect Operation - Links to an existing entity using unique fields\n   * Extracts the 'connect' data type (typically unique identifiers like id, email, etc.)\n   * @example { id: 123, apiAction?: \"connect\" } or { email: \"user@example.com\", apiAction?: \"connect\" }\n   */\n  | (ExtractConnectType<T, \"connect\"> extends never\n      ? never\n      : FlattenRelations<ExtractConnectType<T, \"connect\">>)\n  /**\n   * Update Operation - Modifies an existing related entity\n   * Combines the 'where' clause and 'data' fields into a single flat object\n   * @example { id: 123, name: \"Updated Name\", apiAction?: \"update\" }\n   */\n  | (ExtractUpdateType<T> extends never\n      ? never\n      : FlattenRelations<ExtractUpdateType<T>> & {\n          apiAction?: \"update\";\n        })\n  /**\n   * Delete Operation - Removes a related entity from the database\n   * Requires unique identifier(s) and explicit apiAction: \"delete\"\n   * For arrays, automatically uses deleteMany; for singular relations uses delete\n   * @example { id: 123, apiAction: \"delete\" }\n   */\n  | (T extends {\n      delete?: any;\n    }\n      ? {\n          apiAction: \"delete\";\n        } & ExtractConnectType<T, \"delete\">\n      : never)\n  /**\n   * Disconnect Operation - Breaks the relationship without deleting the entity\n   * Requires unique identifier(s) and explicit apiAction: \"disconnect\"\n   * Only available for optional relations\n   * @example { id: 123, apiAction: \"disconnect\" }\n   */\n  | (T extends {\n      disconnect?: any;\n    }\n      ? {\n          apiAction: \"disconnect\";\n        } & ExtractConnectType<T, \"disconnect\">\n      : never)\n  /**\n   * Set Operation - Replaces all related entities with a new set\n   * Typically used for many-to-many relations to completely replace the relation set\n   * @example { id: 456, apiAction?: \"set\" }\n   */\n  | (T extends {\n      set?: infer S;\n    }\n      ? Unpack<S> & {\n          apiAction?: \"set\";\n        }\n      : never)\n  /**\n   * Delete Many Operation - Removes multiple related entities matching criteria\n   * Requires unique identifier(s) and explicit apiAction: \"deleteMany\"\n   * Used for bulk deletion of related records\n   * @example { id: 123, apiAction: \"deleteMany\" }\n   */\n  | (T extends {\n      deleteMany?: any;\n    }\n      ? {\n          apiAction: \"deleteMany\";\n        } & ExtractConnectType<T, \"deleteMany\">\n      : never);\n\n/**\n * Ensures array relations only accept arrays, not single objects\n * For array relations (one-to-many, many-to-many), forces array type\n * For singular relations (one-to-one, many-to-one), keeps XOR behavior\n * @template T - The original Prisma field type\n * @template Flattened - The flattened relation field type\n */\ntype EnforceArrayRelation<T, Flattened> =\n  IsArrayRelation<T> extends true\n    ? // Array relation: Extract only array types from the union\n      Flattened extends Array<any>\n      ? Flattened\n      : never\n    : // Singular relation: Keep XOR behavior (can be object OR array)\n      Exclude<XOR<Flattened, T>, \"AND\">;\n\ntype FlattenRelations<T> = {\n  [K in keyof T]: IsRelationField<T[K]> extends true\n    ? EnforceArrayRelation<T[K], FlattenRelationField<T[K]>>\n    : T[K] extends object\n      ? T[K] extends Date | null | undefined\n        ? T[K]\n        : FlattenRelations<T[K]>\n      : T[K];\n};\n/**\n * Flattens Prisma relation inputs into a simpler, developer-friendly format\n *\n * Transforms Prisma's nested relation format:\n * ```typescript\n * { posts: { create: [...], connect: [...], update: [...] } }\n * ```\n *\n * Into a flattened format with optional apiAction discriminators:\n * ```typescript\n * { posts: [\n *   { title: \"New Post\" },                    // auto-detected as create\n *   { id: 1 },                                 // auto-detected as connect\n *   { id: 2, title: \"Updated\", apiAction: \"update\" }\n * ]}\n * ```\n *\n * Features:\n * - Preserves non-relation fields as-is\n * - Automatically detects operation type based on field presence\n * - Supports explicit apiAction for disambiguation\n * - Works recursively for deeply nested relations\n * - Enforces array-only types for array relations (one-to-many, many-to-many)\n * - Enforces mutual exclusivity between flattened and Prisma formats for singular relations\n *\n * @see {@link https://wwww.arkosjs.com/docs/api-reference/arkos-prisma-input}\n * @template T - The Prisma input type (e.g., Prisma.UserCreateInput)\n * @returns A flattened version of the input type with simplified relation handling\n *\n * @example\n * ```typescript\n * import { Prisma } from \"@prisma/client\";\n *\n * type FlatUserInput = ArkosPrismaInput<Prisma.UserCreateInput>;\n *\n * const user: FlatUserInput = {\n *   name: \"John\",\n *   email: \"john@example.com\",\n *   posts: [\n *     { title: \"My First Post\" },              // creates new post\n *     { id: 1 },                                // connects to existing post\n *     { id: 2, title: \"Updated\" },              // updates existing post\n *     { id: 3, apiAction: \"delete\" }            // deletes post\n *   ],\n *   profile: { bio: \"Software developer\" }     // singular relation (can be object or array)\n * };\n * ```\n */\nexport type ArkosPrismaInput<T> = FlattenRelations<T>;\n"]}