arkos 1.4.9-beta → 1.4.10-beta

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

@@ -1,553 +0,0 @@
-import fs from "fs/promises";
-import { execSync } from "child_process";
-import path from "path";
-import sheu from "../../sheu.js";
-import { kebabCase } from "../../helpers/change-case.helpers.js";
-import prismaSchemaParser from "../../prisma/prisma-schema-parser.js";
-class StaticTypesGenerator {
-    constructor() {
-        this.packageName = "@arkosjs/types";
-        this.outputDir = path.resolve(process.cwd(), `node_modules/${this.packageName}`);
-    }
-    async generate() {
-        try {
-            await this.generatePrismaClient();
-            await this.ensureOutputDirectory();
-            await this.generateTypeDeclarations();
-            await this.generatePackageJson();
-            sheu.done("Types for @prisma/client and base service generated successfully!");
-        }
-        catch (error) {
-            sheu.error("Failed to generate static types:");
-            console.log(error);
-            throw error;
-        }
-    }
-    async generatePrismaClient() {
-        return new Promise((resolve, reject) => {
-            try {
-                execSync("npx prisma generate", { stdio: "inherit" });
-                resolve();
-            }
-            catch (error) {
-                reject(new Error(`Prisma generation failed: ${error}`));
-            }
-        });
-    }
-    async ensureOutputDirectory() {
-        await fs.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>> = {
-${prismaSchemaParser.models
-            .map((model) => `  "${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.join(this.outputDir, "base.service.d.ts");
-        await fs.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.join(this.outputDir, "package.json");
-        await fs.writeFile(pkgPath, content, { encoding: "utf8" });
-    }
-}
-const staticTypesGenerator = new StaticTypesGenerator();
-export default staticTypesGenerator;
-//# sourceMappingURL=static-types-generator.js.map

package/dist/esm/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"]}