vsrepo 1.2.5 → 1.2.7

package/scripts/configure-prisma-import.mjs

@@ -20,15 +20,16 @@ const GENERATED_HEADER = `/**
 
 `;
 
-const command = args[0]?.startsWith('-') ? 'generate' : args[0] ?? 'generate';
-const commandArgs = command === 'generate' && args[0] !== command ? args : args.slice(1);
+const command = args[0] || 'generate';
 
 if (command !== 'generate') {
   console.error(`Comando desconhecido: ${command}`);
-  console.error('Uso: vsrepo generate --output <dir-output> --prisma <path-prisma>');
+  console.error('Use: vsrepo generate --output <dir-output> --prisma <path-prisma>');
   process.exit(1);
 }
 
+const commandArgs = command === args[0] ? args.slice(1) : args;
+
 const outputFlagIndex = commandArgs.findIndex((arg) => arg === '--output' || arg === '-o');
 const prismaFlagIndex = commandArgs.findIndex((arg) => arg === '--prisma' || arg === '-p');
 
@@ -68,10 +69,10 @@ const packageRoot = installedPackageExists
   ? installedNodeModulesPath
   : path.resolve(scriptDirectory, '..');
 
-const sourceDir = path.join(packageRoot, 'VSRepository');
+const sourceDir = path.join(packageRoot, 'dist');
 
 if (!fs.existsSync(sourceDir)) {
-  console.error(`Nao foi possivel localizar a pasta VSRepository em: ${sourceDir}`);
+  console.error(`Nao foi possivel localizar a pasta dist em: ${sourceDir}`);
   process.exit(1);
 }
 
@@ -98,7 +99,7 @@ for (const fileName of typeFiles) {
   let contents = fs.readFileSync(sourceFile, 'utf8');
 
   contents = contents.replace(
-    /from\s+(['"])@vsrepo\/prisma\/types\1/g,
+    /from\s+(['"])\.\.\/generated\/prisma\/client\1/g,
     `from '${prismaTargetPath === CLASSIC_PRISMA_GENERATED_PATH ? prismaTargetPath : relativeImportPath(path.dirname(targetFile), prismaTargetPath)}'`
   );
 
@@ -194,8 +195,8 @@ if (fs.existsSync(readmeSource)) {
 }
 
 console.log('\nVSRepository gerado com tipagem do Prisma.');
-console.log(`Output: ${outputDir}`);
-console.log(`Prisma usado em: ${prismaTargetPath}`);
+console.log(`Output: ${path.relative(workspaceRoot, outputDir)}`);
+console.log(`Prisma usado em: ${path.relative(workspaceRoot, prismaTargetPath)}`);
 
 function stripKnownExtension(inputPath) {
   return inputPath.replace(/\.(?:d\.ts|ts|js|mjs|cjs)$/i, '');

package/scripts/copy-types.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+
+const srcDir = './src';
+const distDir = './dist';
+
+function copyDefs(dir) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      copyDefs(fullPath);
+    } else if (file.endsWith('.d.ts')) {
+      const relativePath = path.relative(srcDir, fullPath);
+      const destPath = path.join(distDir, relativePath);
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(fullPath, destPath);
+    }
+  }
+}
+
+copyDefs(srcDir);
+console.log('Arquivos .d.ts copiados para a pasta dist.');

package/VSRepository/VSRepoError.js

@@ -1,33 +0,0 @@
-// * Essa é a classe de erro base, pode ser usada em debug para saber se um erro lançado veio do VSRepository
-export class VSRepoError extends Error {
-    constructor(message, type){
-        super(message);
-        this.name = this.constructor.name;
-        this.type = type; // * Tipo do erro para debug
-    }
-}
-
-// * Dessa em diante são classes de erros específicas que estendem da base para saber em qual estágio do VSRepository foi lançado o erro, não vou detalhar cada uma pq o nome é auto explicativo
-export class VSRepoConfigError extends VSRepoError {
-    constructor(message){
-        super(message, "VSREPO_CONFIG");
-    }
-}
-
-export class VSRepoBuildError extends VSRepoError {
-    constructor(message){
-        super(message, "VSREPO_BUILD");
-    }
-}
-
-export class VSRepoExtendError extends VSRepoError {
-    constructor(message){
-        super(message, "VSREPO_EXTEND");
-    }
-}
-
-export class VSRepoRuntimeError extends VSRepoError {
-    constructor(message){
-        super(message, "VSREPO_RUNTIME");
-    }
-}

package/VSRepository/VSRepoUtils.js

@@ -1,150 +0,0 @@
-import z from "zod";
-import { VSRepoConfigError, VSRepoBuildError } from "./VSRepoError.js";
-
-export function mergeWheres(currentWhere, restrictWhere) {
-    const restrictWhereKeys = Object.keys(restrictWhere);
-    for (let i = 0; i < restrictWhereKeys.length; i++) {
-        const restrictWhereKey = restrictWhereKeys[i];
-        const restrictWhereField = restrictWhere[restrictWhereKey];
-
-        if (restrictWhereField === null || typeof restrictWhereField !== "object") {
-            currentWhere[restrictWhereKey] = restrictWhereField;
-        } else if (Array.isArray(restrictWhereField)) {
-            currentWhere[restrictWhereKey] = Array.isArray(currentWhere[restrictWhereKey]) ?
-                restrictWhereField.concat(currentWhere[restrictWhereKey]) :
-                restrictWhereField;
-        } else {
-            currentWhere[restrictWhereKey] = 
-                currentWhere[restrictWhereKey] != null &&
-                typeof currentWhere[restrictWhereKey] === "object" &&
-                !Array.isArray(currentWhere[restrictWhereKey]) ?
-                    Object.assign(currentWhere[restrictWhereKey], restrictWhereField) :
-                    restrictWhereField;
-        }
-    }
-}
-
-const stringSchema = z.string().trim().nonempty();
-const objectSchema = z.looseObject({});
-const booleanSchema = z.boolean();
-
-export function validateConfig(config) {
-    const configSchema = z.strictObject({
-        tableName: stringSchema,
-        pkName: stringSchema,
-        selectModels: z.record(stringSchema, objectSchema).optional(),
-        defaultSelectModel: stringSchema.optional(),
-        requiredWhere: objectSchema.optional(),
-        relations: z.record(
-            stringSchema,
-            z.strictObject({
-                mode: z.enum(['otm', 'mtm', 'mto', 'oto']),
-                restriction: z.enum(['set', 'add']),
-                pk: stringSchema,
-                nullAble: booleanSchema.optional(),
-            })
-        ).optional(),
-        methods: z.record(stringSchema, z.strictObject({
-            map: booleanSchema,
-            selectModel: stringSchema.or(z.literal(false)).optional(),
-            whereType: z.enum(["overwrite", "extending"]).optional(),
-            proxyTo: stringSchema.optional(),
-            pushWhere: objectSchema.optional(),
-            fbMode: z.enum(["one", "list"]).optional(),
-            injectOrdenation: objectSchema.or(z.array(objectSchema)).optional(),
-            injectPagination: objectSchema.optional()
-        })).optional()
-    }).superRefine((config, ctx)=>{
-        if (config.defaultSelectModel && !config.selectModels?.[config.defaultSelectModel]) {
-            ctx.addIssue({
-                code: "vs_custom",
-                path: ["defaultSelectModel"],
-                message: "must be a valid key of 'selectModels'",
-            });
-        }
-
-        if (config.methods) {
-            for (const [key, method] of Object.entries(config.methods)) {
-                if (method.selectModel && !config.selectModels?.[method.selectModel]) {
-                    ctx.addIssue({
-                        code: "vs_custom",
-                        path: ["methods", key, "selectModel"],
-                        message: "must be a valid key of 'selectModels'",
-                    });
-                }
-            }
-        }
-    });
-
-    const configParsed = configSchema.safeParse(config);
-
-    if(!configParsed.success) {
-        const firstIssue = configParsed.error.issues[0];
-        const path = firstIssue.path.length ? firstIssue.path.join(".") : "config";
-        throw new VSRepoConfigError(`[VSRepository] (config) ${path}: ${firstIssue.message}`)
-    }
-
-    return configParsed.data;
-}
-
-export function validateBuildConfig(buildConfig, buildInstance) {
-    const activeSchema = booleanSchema.default(true);
-    const defaultSelectSchema = buildInstance.selectModels ?
-        z.enum(Object.keys(buildInstance.selectModels)).optional()
-        : z.never("can only be passed if you have configured 'selectModels'.");
-    const ignoreRequiredWhereSchema = booleanSchema.default(false);
-
-    const buildConfigSchema = z.strictObject({
-        freeze: booleanSchema.default(true),
-        showWorking: booleanSchema.default(false),
-        baseMethods: z.strictObject({
-            get: z.strictObject({
-                active: activeSchema,
-                defaultSelect: defaultSelectSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            getOrThrow: z.strictObject({
-                active: activeSchema,
-                defaultSelect: defaultSelectSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            getAll: z.strictObject({
-                active: activeSchema,
-                defaultSelect: defaultSelectSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            remove: z.strictObject({
-                active: activeSchema,
-                defaultSelect: defaultSelectSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            save: z.strictObject({
-                active: activeSchema,
-                defaultSelect: defaultSelectSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            removeList: z.strictObject({
-                active: activeSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            total: z.strictObject({
-                active: activeSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-            has: z.strictObject({
-                active: activeSchema,
-                ignoreRequiredWhere: ignoreRequiredWhereSchema
-            }).optional(),
-        }).optional()
-    });
-
-    const buildConfigParsed = buildConfigSchema.safeParse(buildConfig);
-
-    if(!buildConfigParsed.success) {
-        const firstIssue = buildConfigParsed.error.issues[0];
-        const path = firstIssue.path.length ? firstIssue.path.join(".") : "config";
-        throw new VSRepoBuildError(`[VSRepository] (build) ${path}: ${firstIssue.message}`)
-    }
-
-    return buildConfigParsed.data;
-}