rads-db 3.0.84 → 3.1.2

package/integrations/node.mjs

@@ -2,11 +2,11 @@ import fs from "node:fs/promises";
 import fs2 from "node:fs";
 import path from "node:path";
 import _ from "lodash";
-import { parseSchema } from "./lib.mjs";
-export async function generateClient(options) {
-  const normalizedOptions = normalizeOptions(options);
-  console.time("[rads-db] Schema generated in");
-  const schema = await getSchema(normalizedOptions);
+import { createJiti } from "jiti";
+export async function generateClient() {
+  console.time('"node_modules/_rads-db" generated in');
+  const config = await loadConfig();
+  const schemas = await getSchemas(config);
   const nodeModulesPath = path.resolve("./node_modules");
   const radsDbPath = path.join(nodeModulesPath, "./_rads-db");
   if (!fs2.existsSync(nodeModulesPath)) {
@@ -17,14 +17,15 @@ export async function generateClient(options) {
   if (!fs2.existsSync(radsDbPath)) {
     await fs.mkdir(radsDbPath);
   }
+  const schemasOnly = _.mapValues(schemas, (x) => x.schema);
   const indexJsText = `
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema=${JSON.stringify(schema)}
+exports.schemas=${JSON.stringify(schemasOnly)}
 `.trim();
   const indexMjsText = `
-export const schema = ${JSON.stringify(schema)}
+export const schemas = ${JSON.stringify(schemasOnly)}
 `.trim();
-  const indexDtsText = getIndexDts(schema, normalizedOptions);
+  const indexDtsText = getIndexDts(schemas, config);
   await fs.writeFile(path.join(radsDbPath, "./index.js"), indexJsText);
   await fs.writeFile(path.join(radsDbPath, "./index.mjs"), indexMjsText);
   await fs.writeFile(path.join(radsDbPath, "./index.d.ts"), indexDtsText);
@@ -38,67 +39,70 @@ export const schema = ${JSON.stringify(schema)}
         main: "./index.js",
         module: "./index.mjs",
         types: "./index.d.ts"
-        // browser: 'index-browser.js',
       },
       null,
       2
     )
   );
-  console.timeEnd("[rads-db] Schema generated in");
+  console.timeEnd('"node_modules/_rads-db" generated in');
 }
-export async function getSchema(normalizedOptions) {
-  const { entitiesDir, apiUrl } = normalizedOptions;
-  let schema;
-  if (entitiesDir) {
-    if (!fs2.existsSync(entitiesDir))
-      await fs.mkdir(entitiesDir, { recursive: true });
-    const response = await fs.readdir(entitiesDir, { withFileTypes: true });
-    const entities = {};
-    for (const file of response) {
-      if (!file.isFile())
-        continue;
-      if (!file.name.endsWith(".ts"))
-        continue;
-      const text = await fs.readFile(path.resolve(entitiesDir, file.name), "utf-8");
-      entities[file.name.slice(0, -3)] = text;
-    }
-    schema = parseSchema(entities);
-  } else if (apiUrl) {
-    const url = new URL("radsTunnel", apiUrl);
-    const fetchResponse = await fetch(url.href, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ method: "_schema" })
-    });
-    schema = await fetchResponse.json();
-    if (!schema) {
-      throw new Error("Could not download schema from the server. Please check the server URL.");
+async function loadConfig() {
+  const jiti = createJiti(process.cwd());
+  const paths = ["./rads.config.ts", "./rads.config.js"];
+  let config;
+  for (const p of paths) {
+    config = await jiti.import(p, { try: true });
+    if (config)
+      break;
+  }
+  if (!config) {
+    throw new Error(
+      'File "./rads.config.ts" was not found. Please make sure it is present in the root of your project.'
+    );
+  }
+  return config;
+}
+export async function getSchemas(config) {
+  const result = {};
+  for (const key in config.dataSources) {
+    if (!config.dataSources[key].schema) {
+      throw new Error(`Data source "${key}" does not have a schema. Please, specify it in rads.config.ts`);
     }
-  } else {
-    throw new Error("Please specify entitiesDir or apiUrl");
+    result[key] = await config.dataSources[key].schema();
   }
-  return schema;
+  return result;
+}
+function getIndexDts(schemas, config) {
+  const parts = [];
+  const rootTypeFields = [];
+  for (const key in schemas) {
+    let rootTypeName = _.camelCase(key);
+    rootTypeName = rootTypeName[0].toUpperCase() + rootTypeName.slice(1);
+    const indexDtsStr = getIndexDtsInner(schemas[key].schema, rootTypeName, schemas[key].entitiesDir);
+    rootTypeFields.push(`${key}: ${rootTypeName}`);
+    parts.push(indexDtsStr);
+  }
+  parts.push(
+    `
+export interface RadsDb {
+  ${rootTypeFields.join("\n")}
 }
-function normalizeOptions(options) {
-  options = options || {};
-  if (options.entitiesDir && options.apiUrl)
-    throw new Error('You cannot specify both "apiUrl" and "entitiesDir". Choose one.');
-  if (options.apiUrl)
-    return options;
-  return { entitiesDir: "./entities", ...options };
+    `.trim()
+  );
+  return parts.join("\n\n");
 }
-export function getIndexDts(schema, options) {
+export function getIndexDtsInner(schema, rootTypeName, entitiesDir) {
   const imports = [];
   const rootFields = [];
   const whereTypes = [];
   const entityMeta = [];
-  const schemaTypesStr = options.entitiesDir ? "" : getEntityTypesStrFromSchema(schema);
+  const schemaTypesStr = entitiesDir ? "" : getEntityTypesStrFromSchema(schema);
   for (const key in schema) {
     const type = schema[key];
     if (!type.fields)
       continue;
-    if (options.entitiesDir && type.sourceFile) {
-      imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${type.sourceFile}'`);
+    if (entitiesDir && type.sourceFile) {
+      imports.push(`import type { ${type.name} } from '../../${entitiesDir}/${type.sourceFile}'`);
     }
     if (type.decorators?.entity) {
       rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}'>`);
@@ -161,7 +165,7 @@ interface Reference_Where {
 
 ${whereTypes.join("\n\n")}
 
-export interface RadsDb {
+export interface ${rootTypeName} {
   _schema: any
   uploadFile: (args: FileUploadArgs, ctx?: RadsRequestContext) => Promise<{ url: string }>
   ${rootFields.join("\n")}

package/integrations/vite.cjs

@@ -10,7 +10,7 @@ function radsDbVite(options) {
     name: "rads-db",
     config(config, env) {},
     async configResolved(config) {
-      await (0, _node.generateClient)(options);
+      await (0, _node.generateClient)();
     },
     configureServer(server) {
       server.middlewares.use((req, res, next) => {

package/integrations/vite.mjs

@@ -6,7 +6,7 @@ export function radsDbVite(options) {
       config(config, env) {
       },
       async configResolved(config) {
-        await generateClient(options);
+        await generateClient();
       },
       configureServer(server) {
         server.middlewares.use((req, res, next) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.0.84",
+  "version": "3.1.2",
   "packageManager": "pnpm@8.6.1",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "author": "",
@@ -12,6 +12,11 @@
       "require": "./dist/index.cjs",
       "import": "./dist/index.mjs"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "require": "./dist/config.cjs",
+      "import": "./dist/config.mjs"
+    },
     "./drivers/*": {
       "types": "./drivers/*.d.ts",
       "require": "./drivers/*.cjs",
@@ -75,6 +80,7 @@
     "@fastify/deepmerge": "^1.3.0",
     "dataloader": "^2.2.2",
     "ignore": "^5.2.4",
+    "jiti": "^2.4.2",
     "klaw": "^4.1.0",
     "lodash": "^4.17.21",
     "uuid": ">=8",
@@ -104,7 +110,7 @@
   "scripts": {
     "test": "vitest --run && vitest typecheck --run",
     "link-rads-db": "symlink-dir ./test/_rads-db ./node_modules/_rads-db",
-    "generate-test-schema": "ts-node ./src/integrations/cli -d './test/entities'",
+    "generate-test-schema": "jiti ./src/integrations/cli",
     "dev": "pnpm install && pnpm link-rads-db && pnpm build && pnpm generate-test-schema && vitest --ui --test-timeout 300000 --typecheck",
     "lint": "cross-env NODE_ENV=production eslint src/**/*.* test/**/*.*",
     "build": "unbuild"