rads-db 3.2.36 → 3.2.38

package/dist/config.cjs

@@ -2,6 +2,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const fg = require('fast-glob');
 const typescript = require('typescript');
 const _ = require('lodash');
 
@@ -9,6 +10,7 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
 const ___default = /*#__PURE__*/_interopDefaultCompat(_);
 
 const supportedPrimitiveTypes = ["string", "number", "boolean", "Record<string, string>", "Record<string, any>"];
@@ -598,21 +600,98 @@ function verifyRelationFields(result) {
 function defineRadsConfig(config) {
   return config;
 }
-function schemaFromFiles(entitiesDir) {
-  return async () => {
-    if (!fs__default.existsSync(entitiesDir))
-      await fs__default.promises.mkdir(entitiesDir, { recursive: true });
-    const response = await fs__default.promises.readdir(entitiesDir, { withFileTypes: true });
-    const entities = {};
-    for (const file of response) {
-      if (!file.isFile())
+async function expandToDirectories(patterns) {
+  const dirs = [];
+  for (const p of patterns) {
+    if (fg__default.isDynamicPattern(p)) {
+      const matches = await fg__default(p, { onlyDirectories: true, absolute: true });
+      dirs.push(...matches);
+    } else {
+      dirs.push(path__default.resolve(p));
+    }
+  }
+  return dirs;
+}
+async function resolveDirs(pathsArray) {
+  const resolvedDirs = [];
+  for (const p of pathsArray) {
+    if (fg__default.isDynamicPattern(p)) {
+      const matches = await fg__default(p, { onlyDirectories: true, absolute: true });
+      resolvedDirs.push(...matches);
+    } else {
+      const resolved = path__default.resolve(p);
+      if (!fs__default.existsSync(resolved))
+        await fs__default.promises.mkdir(resolved, { recursive: true });
+      resolvedDirs.push(resolved);
+    }
+  }
+  return resolvedDirs;
+}
+async function scanDirs(resolvedDirs) {
+  const entities = {};
+  const entityFilePaths = {};
+  const entityDirs = {};
+  for (const dir of resolvedDirs) {
+    const entries = await fs__default.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".ts"))
         continue;
-      if (!file.name.endsWith(".ts"))
+      const filePath = path__default.join(dir, entry.name);
+      const content = await fs__default.promises.readFile(filePath, "utf-8");
+      const stem = entry.name.slice(0, -3);
+      const hasEntity = content.includes("@entity");
+      if (hasEntity && entityFilePaths[stem]) {
+        throw new Error(
+          `Entity name collision: "${stem}" is defined in multiple locations:
+  ${entityFilePaths[stem]}
+  ${filePath}`
+        );
+      }
+      entities[stem] = content;
+      if (hasEntity) {
+        entityFilePaths[stem] = filePath;
+        entityDirs[stem] = dir;
+      }
+    }
+  }
+  return { entities, entityFilePaths, entityDirs };
+}
+async function validateEntityRules(entityFilePaths, entityDirs, entityRules) {
+  const resolvedRules = await Promise.all(
+    entityRules.map(async (rule) => {
+      const rulePaths = Array.isArray(rule.path) ? rule.path : [rule.path];
+      const dirs = await expandToDirectories(rulePaths);
+      return { rule, dirs };
+    })
+  );
+  for (const [stem, filePath] of Object.entries(entityFilePaths)) {
+    const entityDir = entityDirs[stem];
+    for (const { rule, dirs } of resolvedRules) {
+      const applies = dirs.some((d) => entityDir === d || entityDir.startsWith(d + path__default.sep));
+      if (!applies)
         continue;
-      const text = await fs__default.promises.readFile(path__default.resolve(entitiesDir, file.name), "utf-8");
-      entities[file.name.slice(0, -3)] = text;
+      if (rule.namePrefix && !stem.startsWith(rule.namePrefix)) {
+        throw new Error(`Entity "${stem}" at "${filePath}" must have name prefix "${rule.namePrefix}"`);
+      }
+      if (rule.validate) {
+        const error = rule.validate(stem, filePath);
+        if (error)
+          throw new Error(error);
+      }
+    }
+  }
+}
+function schemaFromFiles(paths, options) {
+  return async () => {
+    const pathsArray = Array.isArray(paths) ? paths : [paths];
+    const resolvedDirs = await resolveDirs(pathsArray);
+    const { entities, entityFilePaths, entityDirs } = await scanDirs(resolvedDirs);
+    if (options?.entityRules?.length) {
+      await validateEntityRules(entityFilePaths, entityDirs, options.entityRules);
     }
-    return { schema: parseSchema(entities), entitiesDir };
+    const isSingleLiteralPath = pathsArray.length === 1 && !fg__default.isDynamicPattern(pathsArray[0]);
+    const entitiesDir = isSingleLiteralPath ? pathsArray[0] : void 0;
+    return { schema: parseSchema(entities), entitiesDir, entitiesDirs: resolvedDirs };
   };
 }
 function schemaFromRadsApi(radsApiUrl) {

package/dist/config.d.ts

@@ -1,16 +1,30 @@
-import { g as RadsConfig, T as TypeDefinition } from './types-eb31ea63.js';
+import { g as RadsConfig, T as TypeDefinition } from './types-f64a81e8.js';
 import 'mssql';
 import '_rads-db';
 
 declare function defineRadsConfig(config: RadsConfig): RadsConfig;
+interface SchemaFromFilesEntityRule {
+    /** Directory path(s) or glob pattern(s) this rule applies to */
+    path: string | string[];
+    /** Entity class name must start with this prefix */
+    namePrefix?: string;
+    /** Custom validator — return an error message to reject the entity, or throw */
+    validate?: (entityName: string, filePath: string) => string | void;
+}
+interface SchemaFromFilesOptions {
+    entityRules?: SchemaFromFilesEntityRule[];
+}
 /**
- * Loads all typescript files in given folder, parses them and outputs schema.
- * @param entitiesDir - path from project root to folder with typescript files, e.g. './entities'
- * @returns schema object
+ * Loads all typescript files with @entity() decorated classes from the given path(s),
+ * parses them and outputs a merged schema.
+ * @param paths - path(s) from project root to folder(s) with entity files; may include glob patterns
+ * @param options - optional validation rules per path
+ * @returns schema loader function
  */
-declare function schemaFromFiles(entitiesDir: string): () => Promise<{
+declare function schemaFromFiles(paths: string | string[], options?: SchemaFromFilesOptions): () => Promise<{
     schema: Record<string, TypeDefinition>;
-    entitiesDir: string;
+    entitiesDir: string | undefined;
+    entitiesDirs: string[];
 }>;
 /**
  * Loads schema from the rads api.
@@ -21,4 +35,4 @@ declare function schemaFromRadsApi(radsApiUrl: string): () => Promise<{
     schema: any;
 }>;
 
-export { defineRadsConfig, schemaFromFiles, schemaFromRadsApi };
+export { SchemaFromFilesEntityRule, SchemaFromFilesOptions, defineRadsConfig, schemaFromFiles, schemaFromRadsApi };

package/dist/config.mjs

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import fg from 'fast-glob';
 import { SyntaxKind, createSourceFile, ScriptTarget } from 'typescript';
 import _ from 'lodash';
 
@@ -590,21 +591,98 @@ function verifyRelationFields(result) {
 function defineRadsConfig(config) {
   return config;
 }
-function schemaFromFiles(entitiesDir) {
-  return async () => {
-    if (!fs.existsSync(entitiesDir))
-      await fs.promises.mkdir(entitiesDir, { recursive: true });
-    const response = await fs.promises.readdir(entitiesDir, { withFileTypes: true });
-    const entities = {};
-    for (const file of response) {
-      if (!file.isFile())
+async function expandToDirectories(patterns) {
+  const dirs = [];
+  for (const p of patterns) {
+    if (fg.isDynamicPattern(p)) {
+      const matches = await fg(p, { onlyDirectories: true, absolute: true });
+      dirs.push(...matches);
+    } else {
+      dirs.push(path.resolve(p));
+    }
+  }
+  return dirs;
+}
+async function resolveDirs(pathsArray) {
+  const resolvedDirs = [];
+  for (const p of pathsArray) {
+    if (fg.isDynamicPattern(p)) {
+      const matches = await fg(p, { onlyDirectories: true, absolute: true });
+      resolvedDirs.push(...matches);
+    } else {
+      const resolved = path.resolve(p);
+      if (!fs.existsSync(resolved))
+        await fs.promises.mkdir(resolved, { recursive: true });
+      resolvedDirs.push(resolved);
+    }
+  }
+  return resolvedDirs;
+}
+async function scanDirs(resolvedDirs) {
+  const entities = {};
+  const entityFilePaths = {};
+  const entityDirs = {};
+  for (const dir of resolvedDirs) {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".ts"))
         continue;
-      if (!file.name.endsWith(".ts"))
+      const filePath = path.join(dir, entry.name);
+      const content = await fs.promises.readFile(filePath, "utf-8");
+      const stem = entry.name.slice(0, -3);
+      const hasEntity = content.includes("@entity");
+      if (hasEntity && entityFilePaths[stem]) {
+        throw new Error(
+          `Entity name collision: "${stem}" is defined in multiple locations:
+  ${entityFilePaths[stem]}
+  ${filePath}`
+        );
+      }
+      entities[stem] = content;
+      if (hasEntity) {
+        entityFilePaths[stem] = filePath;
+        entityDirs[stem] = dir;
+      }
+    }
+  }
+  return { entities, entityFilePaths, entityDirs };
+}
+async function validateEntityRules(entityFilePaths, entityDirs, entityRules) {
+  const resolvedRules = await Promise.all(
+    entityRules.map(async (rule) => {
+      const rulePaths = Array.isArray(rule.path) ? rule.path : [rule.path];
+      const dirs = await expandToDirectories(rulePaths);
+      return { rule, dirs };
+    })
+  );
+  for (const [stem, filePath] of Object.entries(entityFilePaths)) {
+    const entityDir = entityDirs[stem];
+    for (const { rule, dirs } of resolvedRules) {
+      const applies = dirs.some((d) => entityDir === d || entityDir.startsWith(d + path.sep));
+      if (!applies)
         continue;
-      const text = await fs.promises.readFile(path.resolve(entitiesDir, file.name), "utf-8");
-      entities[file.name.slice(0, -3)] = text;
+      if (rule.namePrefix && !stem.startsWith(rule.namePrefix)) {
+        throw new Error(`Entity "${stem}" at "${filePath}" must have name prefix "${rule.namePrefix}"`);
+      }
+      if (rule.validate) {
+        const error = rule.validate(stem, filePath);
+        if (error)
+          throw new Error(error);
+      }
+    }
+  }
+}
+function schemaFromFiles(paths, options) {
+  return async () => {
+    const pathsArray = Array.isArray(paths) ? paths : [paths];
+    const resolvedDirs = await resolveDirs(pathsArray);
+    const { entities, entityFilePaths, entityDirs } = await scanDirs(resolvedDirs);
+    if (options?.entityRules?.length) {
+      await validateEntityRules(entityFilePaths, entityDirs, options.entityRules);
     }
-    return { schema: parseSchema(entities), entitiesDir };
+    const isSingleLiteralPath = pathsArray.length === 1 && !fg.isDynamicPattern(pathsArray[0]);
+    const entitiesDir = isSingleLiteralPath ? pathsArray[0] : void 0;
+    return { schema: parseSchema(entities), entitiesDir, entitiesDirs: resolvedDirs };
   };
 }
 function schemaFromRadsApi(radsApiUrl) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { E as EntityDecoratorArgs, U as UiDecoratorArgs, a as UiFieldDecoratorArgs, V as ValidateEntityDecoratorArgs, b as ValidateFieldDecoratorArgs, F as FieldDecoratorArgs, C as ComputedDecoratorArgs, S as Schema, D as DriverConstructor, c as Driver, d as ComputedContext, R as RadsRequestContext, e as CreateRadsDbArgs, f as CreateRadsDbClientArgs } from './types-eb31ea63.js';
-export { O as Change, x as ComputedContextGlobal, k as CreateRadsArgsDrivers, m as CreateRadsDbArgsNormalized, an as DeepKeys, ai as DeepPartial, af as DeepPartialArrayItem, ad as DeepPartialWithNulls, ae as DeepPartialWithNullsItem, ag as DeepPartialWithoutNulls, ah as DeepPartialWithoutNullsItem, ao as EntityMethods, w as EnumDefinition, v as FieldDefinition, J as FileSystemNode, u as FileUploadArgs, q as FileUploadDriver, p as FileUploadResult, H as GenerateClientNormalizedOptions, B as GenerateClientOptions, a9 as Get, $ as GetAggArgs, a0 as GetAggArgsAgg, a3 as GetAggArgsAny, a6 as GetAggResponse, _ as GetArgs, a2 as GetArgsAny, a5 as GetArgsInclude, Q as GetManyArgs, a1 as GetManyArgsAny, a7 as GetManyResponse, a8 as GetResponse, aa as GetResponseInclude, ab as GetResponseIncludeSelect, ac as GetResponseNoInclude, s as GetRestRoutesArgs, G as GetRestRoutesOptions, t as GetRestRoutesResponse, ak as InverseRelation, am as JsonPutOperations, M as MinimalDriver, al as Put, P as PutEffect, g as RadsConfig, h as RadsConfigDataSource, r as RadsDbInstance, N as RadsFeature, y as RadsHookDoc, L as RadsUiSlotDefinition, K as RadsUiSlotName, I as RadsVitePluginOptions, aj as Relation, i as RequiredFields, l as RestDriverOptions, A as RestFileUploadDriverOptions, n as SchemaLoadResult, o as SchemaValidators, z as SqlDriverOptions, T as TypeDefinition, j as ValidateStringDecoratorArgs, X as VerifyManyArgs, a4 as VerifyManyArgsAny, Y as VerifyManyResponse, Z as Where, W as WhereJsonContains } from './types-eb31ea63.js';
+import { E as EntityDecoratorArgs, U as UiDecoratorArgs, a as UiFieldDecoratorArgs, V as ValidateEntityDecoratorArgs, b as ValidateFieldDecoratorArgs, F as FieldDecoratorArgs, C as ComputedDecoratorArgs, S as Schema, D as DriverConstructor, c as Driver, d as ComputedContext, R as RadsRequestContext, e as CreateRadsDbArgs, f as CreateRadsDbClientArgs } from './types-f64a81e8.js';
+export { O as Change, x as ComputedContextGlobal, k as CreateRadsArgsDrivers, m as CreateRadsDbArgsNormalized, an as DeepKeys, ai as DeepPartial, af as DeepPartialArrayItem, ad as DeepPartialWithNulls, ae as DeepPartialWithNullsItem, ag as DeepPartialWithoutNulls, ah as DeepPartialWithoutNullsItem, ao as EntityMethods, w as EnumDefinition, v as FieldDefinition, J as FileSystemNode, u as FileUploadArgs, q as FileUploadDriver, p as FileUploadResult, H as GenerateClientNormalizedOptions, B as GenerateClientOptions, a9 as Get, $ as GetAggArgs, a0 as GetAggArgsAgg, a3 as GetAggArgsAny, a6 as GetAggResponse, _ as GetArgs, a2 as GetArgsAny, a5 as GetArgsInclude, Q as GetManyArgs, a1 as GetManyArgsAny, a7 as GetManyResponse, a8 as GetResponse, aa as GetResponseInclude, ab as GetResponseIncludeSelect, ac as GetResponseNoInclude, s as GetRestRoutesArgs, G as GetRestRoutesOptions, t as GetRestRoutesResponse, ak as InverseRelation, am as JsonPutOperations, M as MinimalDriver, al as Put, P as PutEffect, g as RadsConfig, h as RadsConfigDataSource, r as RadsDbInstance, N as RadsFeature, y as RadsHookDoc, L as RadsUiSlotDefinition, K as RadsUiSlotName, I as RadsVitePluginOptions, aj as Relation, i as RequiredFields, l as RestDriverOptions, A as RestFileUploadDriverOptions, n as SchemaLoadResult, o as SchemaValidators, z as SqlDriverOptions, T as TypeDefinition, j as ValidateStringDecoratorArgs, X as VerifyManyArgs, a4 as VerifyManyArgsAny, Y as VerifyManyResponse, Z as Where, W as WhereJsonContains } from './types-f64a81e8.js';
 import { RadsDb } from '_rads-db';
 export { RadsDb } from '_rads-db';
 import 'mssql';

package/dist/{types-eb31ea63.d.ts → types-f64a81e8.d.ts}

@@ -287,6 +287,7 @@ type Schema = Record<string, TypeDefinition>;
 interface SchemaLoadResult {
     schema: Schema;
     entitiesDir?: string;
+    entitiesDirs?: string[];
 }
 type SchemaValidators = Record<string, (item: any, oldDoc?: any) => any>;
 interface TypeDefinition {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.2.36",
+  "version": "3.2.38",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "author": "",
   "license": "ISC",
@@ -83,6 +83,7 @@
   "dependencies": {
     "@fastify/deepmerge": "^1.3.0",
     "dataloader": "^2.2.2",
+    "fast-glob": "^3.3.3",
     "ignore": "^5.2.4",
     "jiti": "^2.4.2",
     "klaw": "^4.1.0",