rads-db 0.1.8 → 0.1.11

package/dist/index.cjs

@@ -1,15 +1,15 @@
 'use strict';
 
-const defaultSchema = require('.rads-db/schema.json');
 const zod = require('zod');
 const _ = require('lodash');
 const pluralize = require('pluralize');
+const schema = require('_rads-db');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const defaultSchema__default = /*#__PURE__*/_interopDefaultCompat(defaultSchema);
 const ___default = /*#__PURE__*/_interopDefaultCompat(_);
 const pluralize__default = /*#__PURE__*/_interopDefaultCompat(pluralize);
+const schema__default = /*#__PURE__*/_interopDefaultCompat(schema);
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -379,15 +379,15 @@ function field(meta) {
 
 function createRads(args) {
   args = { ...args };
-  const schema = args.schema || defaultSchema__default;
-  const validators = generateValidators(schema);
-  return generateMethods(schema, validators, args);
+  const s = args.schema || schema__default;
+  const validators = generateValidators(s);
+  return generateMethods(s, validators, args);
 }
 function getRestRoutes(db, prefix = "/") {
   const routes = {};
-  const schema = db._schema;
-  for (const key in schema) {
-    const entity = schema[key];
+  const schema2 = db._schema;
+  for (const key in schema2) {
+    const entity = schema2[key];
     if (!entity.decorators?.entity)
       continue;
     routes[`${prefix}${entity.handle}`] = {

package/dist/index.d.ts

@@ -1,4 +1,51 @@
 import { HTTPMethod } from 'h3';
+import { EntityMeta, RadsDb } from '_rads-db';
+export { RadsDb } from '_rads-db';
+
+interface GetManyArgs<E, EN extends keyof EntityMeta, W> extends GetArgs<E, EN, W> {
+    cursor?: string;
+    maxItemCount?: number;
+    orderBy?: string;
+}
+interface GetArgs<E, EN extends keyof EntityMeta, W> {
+    where?: W;
+    include?: GetArgsInclude<E, EN>;
+}
+type GetManyArgsAny = GetManyArgs<any, any, any>;
+type GetArgsAny = GetArgs<any, any, any>;
+type GetArgsInclude<E, EN extends keyof EntityMeta, R extends keyof E = keyof EntityMeta[EN]['relations'] & keyof E> = [R] extends [never] ? Record<string, never> : {
+    _select?: EntityMeta[EN]['primitives'][];
+} & {
+    [K in R]?: GetArgsInclude<NonNullable<E[K]>, EntityMeta[EN]['relations'][K]>;
+};
+interface GetManyResponse<E, EN extends keyof EntityMeta, A extends GetArgs<E, EN, any>> {
+    nodes: GetResponse<E, EN, A>[];
+    cursor?: string | null;
+}
+type GetResponse<E, EN extends keyof EntityMeta, A extends GetArgs<E, EN, any>> = A extends {
+    include: any;
+} ? GetResponseInclude<E, EN, A['include']> : GetResponseNoInclude<E, EN>;
+type GetResponseInclude<E, EN extends keyof EntityMeta, I extends GetArgsInclude<E, EN>> = I extends {
+    _select: string[];
+} ? GetResponseIncludeSelect<E, I> : {
+    [K in keyof E]: K extends keyof EntityMeta[EN]['relations'] ? K extends keyof I ? GetResponseInclude<E[K], EntityMeta[EN]['relations'][K], I[K]> : Pick<E[K], 'id'> : E[K];
+};
+interface GetResponseIncludeSelect<E, I> {
+}
+type GetResponseNoInclude<E, EN extends keyof EntityMeta> = {
+    [K in keyof E]: K extends keyof EntityMeta[EN]['relations'] ? Pick<E[K], 'id'> : E[K];
+};
+type PutArgs<T> = T extends object ? {
+    id: string;
+} & {
+    [P in keyof T]?: PutArgs<T[P]>;
+} : T;
+interface EntityMethods<E, EN extends keyof EntityMeta, W> {
+    get<A extends GetArgs<E, EN, W>>(args: A): GetResponse<E, EN, A>;
+    getMany<A extends GetManyArgs<E, EN, W>>(args: A): GetManyResponse<E, EN, A>;
+    put(data: PutArgs<E>): GetResponseNoInclude<E, EN>;
+    putMany(data: PutArgs<E>[]): GetResponseNoInclude<E, EN>[];
+}
 
 interface EntityDecoratorArgs {
     driver?: string;
@@ -25,13 +72,13 @@ interface TypeDefinition {
 type MaybePromise<T> = Promise<T> | T;
 interface MinimalDriver {
     putMany: <T extends Record<string, any>>(item: T[]) => MaybePromise<void>;
-    getMany: (args: GetManyArgs) => MaybePromise<{
+    getMany: (args: GetManyArgs<any, any, any>) => MaybePromise<{
         nodes: Record<string, any>[];
         cursor: string | null;
     }>;
 }
 interface Driver extends MinimalDriver {
-    getAll: (args: GetManyArgs) => MaybePromise<Record<string, any>[]>;
+    getAll: (args: GetManyArgs<any, any, any>) => MaybePromise<Record<string, any>[]>;
 }
 interface FieldDefinition {
     name: string;
@@ -41,25 +88,6 @@ interface FieldDefinition {
     comment?: string;
     decorators?: Record<string, Record<string, any>>;
 }
-interface GetManyArgs extends GetArgs {
-    orderBy?: string;
-    maxItemCount?: number;
-    cursor?: string;
-}
-interface GetArgs {
-    where?: Record<string, any>;
-    include?: Record<string, any>;
-}
-interface EntityMethods<T = Record<string, any>> {
-    get: (args: GetArgs) => Promise<T>;
-    getMany: (args: GetManyArgs) => Promise<{
-        nodes: T[];
-        cursor: string | null;
-    }>;
-    getAll: (args: GetManyArgs) => Promise<T[]>;
-    put: (data: T) => Promise<T>;
-    putMany: (data: T[]) => Promise<T[]>;
-}
 interface RestDriverOptions {
     type: 'restApi';
     /** @default '/api' */
@@ -74,17 +102,15 @@ interface MemoryDriverOptions {
     type: 'memory';
 }
 type DriverOptions = RestDriverOptions | MemoryDriverOptions;
-interface RadsDb {
-    [key: string]: EntityMethods;
-}
-interface GenerateClientOptions {
-    entitiesDir?: string;
+type GenerateClientOptions = Partial<GenerateClientNormalizedOptions>;
+interface GenerateClientNormalizedOptions {
+    entitiesDir: string;
 }
 
 declare function entity(meta?: EntityDecoratorArgs): (classConstructor: Function, _ctx?: ClassDecoratorContext<any>) => void;
 declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
 
-declare function createRads(args?: CreateRadsArgs): RadsDb;
+declare function createRads(args?: CreateRadsArgs): Record<string, any>;
 declare function getRestRoutes(db: RadsDb, prefix?: string): Record<string, Record<string, Function>>;
 
-export { CreateRadsArgs, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientOptions, GetArgs, GetManyArgs, MemoryDriverOptions, MinimalDriver, RadsDb, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, createRads, entity, field, getRestRoutes };
+export { CreateRadsArgs, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientNormalizedOptions, GenerateClientOptions, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MinimalDriver, PutArgs, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, createRads, entity, field, getRestRoutes };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import defaultSchema from '.rads-db/schema.json';
 import { z } from 'zod';
 import _ from 'lodash';
 import pluralize from 'pluralize';
+import schema from '_rads-db';
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -371,15 +371,15 @@ function field(meta) {
 
 function createRads(args) {
   args = { ...args };
-  const schema = args.schema || defaultSchema;
-  const validators = generateValidators(schema);
-  return generateMethods(schema, validators, args);
+  const s = args.schema || schema;
+  const validators = generateValidators(s);
+  return generateMethods(s, validators, args);
 }
 function getRestRoutes(db, prefix = "/") {
   const routes = {};
-  const schema = db._schema;
-  for (const key in schema) {
-    const entity = schema[key];
+  const schema2 = db._schema;
+  for (const key in schema2) {
+    const entity = schema2[key];
     if (!entity.decorators?.entity)
       continue;
     routes[`${prefix}${entity.handle}`] = {

package/drivers/restApi.d.ts

@@ -1,5 +1,5 @@
 declare const _default: (schema: Schema, entity: string, options: RestDriverOptions) => {
-    getMany(args: GetManyArgs): Promise<any>;
+    getMany(args: GetManyArgs<any, any, any>): Promise<any>;
     putMany<T extends Record<string, any>>(item: T): Promise<void>;
 };
 export default _default;

package/integrations/cli.cjs

@@ -0,0 +1,7 @@
+// #!/usr/bin/env node
+"use strict";
+
+var _node = require("./node.cjs");
+(0, _node.generateClient)({
+  entitiesDir: "./test/entities"
+});

package/integrations/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/integrations/cli.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { generateClient } from "./node.mjs";
+generateClient({ entitiesDir: "./test/entities" });

package/integrations/node.cjs

@@ -7,6 +7,7 @@ exports.generateClient = generateClient;
 var _promises = _interopRequireDefault(require("node:fs/promises"));
 var _nodeFs = _interopRequireDefault(require("node:fs"));
 var _nodePath = _interopRequireDefault(require("node:path"));
+var _lodash = _interopRequireDefault(require("lodash"));
 var _lib = require("./lib.cjs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 async function generateClient(options) {
@@ -18,6 +19,7 @@ async function generateClient(options) {
     entitiesDir
   } = normalizedOptions;
   console.time("[rads-db] Schema generated in");
+  if (!_nodeFs.default.existsSync(entitiesDir)) await _promises.default.mkdir(entitiesDir);
   const response = await _promises.default.readdir(entitiesDir, {
     withFileTypes: true
   });
@@ -30,19 +32,122 @@ async function generateClient(options) {
   }
   const schema = (0, _lib.parseSchema)(entities);
   const nodeModulesPath = _nodePath.default.resolve("./node_modules");
-  const radsDbPath = _nodePath.default.join(nodeModulesPath, "./.rads-db");
+  const radsDbPath = _nodePath.default.join(nodeModulesPath, "./_rads-db");
   if (!_nodeFs.default.existsSync(nodeModulesPath)) {
     throw new Error(`node_modules was not found! Please ensure that node_modules is present in the current working directory.`);
   }
   if (!_nodeFs.default.existsSync(radsDbPath)) {
     await _promises.default.mkdir(radsDbPath);
   }
-  await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./schema.json"), JSON.stringify(schema, null, 2));
+  const indexJsText = `
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema=${JSON.stringify(schema)}
+`.trim();
+  const indexMjsText = `
+export const schema = ${JSON.stringify(schema)}
+`.trim();
+  await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./index.js"), indexJsText);
+  await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./index.mjs"), indexMjsText);
+  await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./index.d.ts"), getIndexDts(schema, normalizedOptions));
   await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./package.json"), JSON.stringify({
-    name: ".rads-db",
-    // main: 'index.js',
-    types: "index.d.ts"
+    name: "_rads-db",
+    main: "./index.js",
+    module: "./index.mjs",
+    types: "./index.d.ts"
     // browser: 'index-browser.js',
   }, null, 2));
   console.timeEnd("[rads-db] Schema generated in");
+}
+function getIndexDts(schema, options) {
+  const imports = [];
+  const rootFields = [];
+  const whereTypes = [];
+  const entityMeta = [];
+  for (const key in schema) {
+    const type = schema[key];
+    if (!type.decorators.entity) continue;
+    imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${key}'`);
+    rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}', ${type.name}_Where>`);
+    const fieldsArray = Object.values(type.fields);
+    entityMeta.push({
+      type: type.name,
+      relations: _lodash.default.fromPairs(fieldsArray.filter(f => schema[f.type]?.decorators?.entity).map(x => [x.name, x.type])),
+      primitives: fieldsArray.filter(f => !schema[f.type]?.decorators?.entity).map(x => `'${x.name}'`).join(" | ")
+    });
+    const whereFields = getWhereFields(schema, type);
+    whereTypes.push(`
+export interface ${type.name}_Where {
+${whereFields.join("\n")}
+}`.trim());
+  }
+  const entityMetaStr = entityMeta.map(x => `
+  '${x.type}': {
+    type: ${x.type}
+    primitives: ${x.primitives}
+    relations: ${JSON.stringify(x.relations)}
+  }
+      `.trim()).join("\n");
+  return `
+import type { EntityMethods } from 'rads-db'
+${imports.join("\n")}
+
+export interface EntityMeta {
+  ${entityMetaStr}
+}
+
+interface Reference_Where {
+  id?: string
+  id_in?: string[]
+}
+
+${whereTypes.join("\n\n")}
+
+export interface RadsDb {
+  _schema: any
+  ${rootFields.join("\n")}
+}
+  `.trim();
+}
+function getWhereFields(schema, type) {
+  const result = [];
+  for (const f in type.fields) {
+    result.push(...getWhereFieldsFor(schema, type, f));
+  }
+  return result;
+}
+function getWhereFieldsFor(schema, type, fieldKey) {
+  const field = type.fields[fieldKey];
+  const {
+    name
+  } = field;
+  const fieldTypeName = field.type;
+  let whereTypeName = fieldTypeName;
+  const fieldType = schema[fieldTypeName];
+  const result = getWhereFieldsForInner(schema, type, fieldKey);
+  if (fieldType) {
+    if (fieldType?.decorators?.entity) {
+      whereTypeName = `{ id?: string, id_in?: string[] }`;
+    }
+    if (fieldType.fields) whereTypeName = `Partial<${whereTypeName}>`;
+  } else {
+    result.unshift(`${name}_in?: ${whereTypeName}[]`);
+  }
+  if (!field.isRequired) {
+    result.unshift(`${name}_isNull?: boolean`);
+  }
+  result.unshift(`${name}?: ${whereTypeName}`);
+  return result;
+}
+function getWhereFieldsForInner(schema, type, fieldKey) {
+  const field = type.fields[fieldKey];
+  const {
+    name
+  } = field;
+  if (field.type === "string") {
+    return [`${name}_istartsWith?: string`, `${name}_startsWith?: string`, `${name}_icontains?: string`, `${name}_contains?: string`, `${name}_iendsWith?: string`, `${name}_endsWith?: string`, `${name}_gt?: string`, `${name}_gte?: string`, `${name}_lt?: string`, `${name}_lte?: string`];
+  }
+  if (field.type === "number") {
+    return [`${name}_gt?: number`, `${name}_gte?: number`, `${name}_lt?: string`, `${name}_lte?: string`];
+  }
+  return [];
 }

package/integrations/node.mjs

@@ -1,11 +1,14 @@
 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 = { entitiesDir: "./entities", ...options };
   const { entitiesDir } = normalizedOptions;
   console.time("[rads-db] Schema generated in");
+  if (!fs2.existsSync(entitiesDir))
+    await fs.mkdir(entitiesDir);
   const response = await fs.readdir(entitiesDir, { withFileTypes: true });
   const entities = {};
   for (const file of response) {
@@ -18,7 +21,7 @@ export async function generateClient(options) {
   }
   const schema = parseSchema(entities);
   const nodeModulesPath = path.resolve("./node_modules");
-  const radsDbPath = path.join(nodeModulesPath, "./.rads-db");
+  const radsDbPath = path.join(nodeModulesPath, "./_rads-db");
   if (!fs2.existsSync(nodeModulesPath)) {
     throw new Error(
       `node_modules was not found! Please ensure that node_modules is present in the current working directory.`
@@ -27,14 +30,24 @@ export async function generateClient(options) {
   if (!fs2.existsSync(radsDbPath)) {
     await fs.mkdir(radsDbPath);
   }
-  await fs.writeFile(path.join(radsDbPath, "./schema.json"), JSON.stringify(schema, null, 2));
+  const indexJsText = `
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema=${JSON.stringify(schema)}
+`.trim();
+  const indexMjsText = `
+export const schema = ${JSON.stringify(schema)}
+`.trim();
+  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"), getIndexDts(schema, normalizedOptions));
   await fs.writeFile(
     path.join(radsDbPath, "./package.json"),
     JSON.stringify(
       {
-        name: ".rads-db",
-        // main: 'index.js',
-        types: "index.d.ts"
+        name: "_rads-db",
+        main: "./index.js",
+        module: "./index.mjs",
+        types: "./index.d.ts"
         // browser: 'index-browser.js',
       },
       null,
@@ -43,3 +56,109 @@ export async function generateClient(options) {
   );
   console.timeEnd("[rads-db] Schema generated in");
 }
+function getIndexDts(schema, options) {
+  const imports = [];
+  const rootFields = [];
+  const whereTypes = [];
+  const entityMeta = [];
+  for (const key in schema) {
+    const type = schema[key];
+    if (!type.decorators.entity)
+      continue;
+    imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${key}'`);
+    rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}', ${type.name}_Where>`);
+    const fieldsArray = Object.values(type.fields);
+    entityMeta.push({
+      type: type.name,
+      relations: _.fromPairs(fieldsArray.filter((f) => schema[f.type]?.decorators?.entity).map((x) => [x.name, x.type])),
+      primitives: fieldsArray.filter((f) => !schema[f.type]?.decorators?.entity).map((x) => `'${x.name}'`).join(" | ")
+    });
+    const whereFields = getWhereFields(schema, type);
+    whereTypes.push(
+      `
+export interface ${type.name}_Where {
+${whereFields.join("\n")}
+}`.trim()
+    );
+  }
+  const entityMetaStr = entityMeta.map(
+    (x) => `
+  '${x.type}': {
+    type: ${x.type}
+    primitives: ${x.primitives}
+    relations: ${JSON.stringify(x.relations)}
+  }
+      `.trim()
+  ).join("\n");
+  return `
+import type { EntityMethods } from 'rads-db'
+${imports.join("\n")}
+
+export interface EntityMeta {
+  ${entityMetaStr}
+}
+
+interface Reference_Where {
+  id?: string
+  id_in?: string[]
+}
+
+${whereTypes.join("\n\n")}
+
+export interface RadsDb {
+  _schema: any
+  ${rootFields.join("\n")}
+}
+  `.trim();
+}
+function getWhereFields(schema, type) {
+  const result = [];
+  for (const f in type.fields) {
+    result.push(...getWhereFieldsFor(schema, type, f));
+  }
+  return result;
+}
+function getWhereFieldsFor(schema, type, fieldKey) {
+  const field = type.fields[fieldKey];
+  const { name } = field;
+  const fieldTypeName = field.type;
+  let whereTypeName = fieldTypeName;
+  const fieldType = schema[fieldTypeName];
+  const result = getWhereFieldsForInner(schema, type, fieldKey);
+  if (fieldType) {
+    if (fieldType?.decorators?.entity) {
+      whereTypeName = `{ id?: string, id_in?: string[] }`;
+    }
+    if (fieldType.fields)
+      whereTypeName = `Partial<${whereTypeName}>`;
+  } else {
+    result.unshift(`${name}_in?: ${whereTypeName}[]`);
+  }
+  if (!field.isRequired) {
+    result.unshift(`${name}_isNull?: boolean`);
+  }
+  result.unshift(`${name}?: ${whereTypeName}`);
+  return result;
+}
+function getWhereFieldsForInner(schema, type, fieldKey) {
+  const field = type.fields[fieldKey];
+  const { name } = field;
+  if (field.type === "string") {
+    return [
+      `${name}_istartsWith?: string`,
+      `${name}_startsWith?: string`,
+      `${name}_icontains?: string`,
+      `${name}_contains?: string`,
+      `${name}_iendsWith?: string`,
+      `${name}_endsWith?: string`,
+      `${name}_gt?: string`,
+      `${name}_gte?: string`,
+      `${name}_lt?: string`,
+      `${name}_lte?: string`
+    ];
+  }
+  if (field.type === "number") {
+    return [`${name}_gt?: number`, `${name}_gte?: number`, `${name}_lt?: string`, `${name}_lte?: string`];
+  }
+  return [];
+}

package/integrations/nuxtModuleHandler.cjs

@@ -14,6 +14,7 @@ var _default = (0, _h.defineEventHandler)(event => {
   const p = (0, _h.getRequestPath)(event);
   const query = (0, _h.getQuery)(event);
   const rp = (0, _h.getRouterParams)(event);
+  const prefix = "";
   console.log(path, p, query, rp);
   if (method === "POST") {}
   if (path === `${prefix}tcUser`) {
@@ -32,7 +33,7 @@ var _default = (0, _h.defineEventHandler)(event => {
 });
 module.exports = _default;
 function getRoutes(entities) {
-  const prefix2 = "/api/";
+  const prefix = "/api/";
   const routes2 = {};
   for (const entityKey in entities) {}
 }

package/integrations/nuxtModuleHandler.mjs

@@ -7,6 +7,7 @@ export default defineEventHandler((event) => {
   const p = getRequestPath(event);
   const query = getQuery(event);
   const rp = getRouterParams(event);
+  const prefix = "";
   console.log(path, p, query, rp);
   if (method === "POST") {
   }
@@ -21,7 +22,7 @@ export default defineEventHandler((event) => {
   console.log(schema);
 });
 function getRoutes(entities) {
-  const prefix2 = "/api/";
+  const prefix = "/api/";
   const routes2 = {};
   for (const entityKey in entities) {
   }

package/package.json

@@ -5,6 +5,9 @@
     "drivers",
     "integrations"
   ],
+  "bin": {
+    "rads-db": "integrations/cli.cjs"
+  },
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -25,7 +28,7 @@
       "require": "./integrations/*.cjs"
     }
   },
-  "version": "0.1.8",
+  "version": "0.1.11",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "keywords": [],
   "author": "",
@@ -36,6 +39,7 @@
   },
   "devDependencies": {
     "@vitest/ui": "^0.31.0",
+    "symlink-dir": "^5.1.1",
     "tsup": "^6.7.0",
     "unbuild": "^1.2.1",
     "vite": "^4.0.0",
@@ -52,8 +56,10 @@
     "zod": "^3.21.4"
   },
   "scripts": {
-    "test": "vitest",
+    "test": "vitest && vitest typecheck",
+    "generate-test-client": "symlink-dir ./test/_rads-db ./node_modules/_rads-db && node ./test/generateClient.ts",
     "dev": "pnpm install --frozen-lockfile && vitest --ui",
+    "dev-typecheck": "vitest typecheck --ui",
     "build": "unbuild"
   }
 }