@uql/core 3.1.0 → 3.1.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.1.1](https://github.com/rogerpadilla/uql/compare/@uql/core@3.1.0...@uql/core@3.1.1) (2025-12-30)
+
+
+### Bug Fixes
+
+* adjust relative paths for README and CHANGELOG in copyfiles script ([741c2ee](https://github.com/rogerpadilla/uql/commit/741c2ee8839376ca89a860a53950ef6b6d234596))
+
+
+
+
+
 # [3.1.0](https://github.com/rogerpadilla/uql/compare/@uql/core@3.0.0...@uql/core@3.1.0) (2025-12-30)
 
 

package/dist/CHANGELOG.md

@@ -0,0 +1,186 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. Please add new changes to the top.
+
+date format is [yyyy-mm-dd]
+## [2.0.0] - 2025-12-29
+- **Major Rebranding**: Rebranded the project from **Nukak** to **UQL** (Universal Query Language - this was the original name!).
+  - New Slogan: **"One Language. Frontend to Backend."**
+  - Project homepage: [uql.app](https://uql.app).
+- **Package Unification**: Unified all database adapters (`mysql`, `postgres`, `maria`, `sqlite`, `mongo`) and `express` middleware into a single core package: `@uql/core`.
+- **Scoped Naming**:
+  - `@uql/core`: The main ORM engine and all database adapters.
+  - `@uql/migrate`: The database migration system (formerly `nukak-migrate`).
+- **Improved API Surface**:
+  - Database-specific logic is now accessible via sub-paths (e.g., `import { ... } from '@uql/core/postgres'`).
+  - Unified `NamingStrategy` and `QueryContext` across all unified adapters.
+- **Build & Distribution**:
+  - Integrated `bunchee` for high-performance browser bundle generation (`@uql/core/browser`).
+  - Minimized core dependency footprint by moving database drivers to optional `peerDependencies`.
+- **Enhanced Type Safety**: Fully updated internal type resolution to support the unified package structure.
+
+## [1.8.0] - 2025-12-29
+- **New Feature**: Added support for **Naming Strategies**.
+  - Automatically translate TypeScript entity and property names to database-specific identifiers (e.g., camelCase to snake_case).
+  - Built-in `DefaultNamingStrategy` and `SnakeCaseNamingStrategy`.
+  - Comprehensive support across all SQL dialects and MongoDB.
+- **Refactoring**:
+  - Unified naming and metadata resolution logic into a new `AbstractDialect` base class shared by both DML (Dialects) and DDL (Schema Generators).
+  - Improved `MongoDialect` to respect naming strategies for collection and field names on both read and write operations.
+
+## [1.7.0] - 2025-12-29
+- **New Package**: Introduced `nukak-migrate` for database migrations.
+  - Supports version-controlled schema changes via local migration files.
+  - Automatic migration generation from entity definitions using schema introspection.
+  - Full support for PostgreSQL, MySQL, MariaDB, and SQLite.
+  - CLI tool for managing migrations (`up`, `down`, `status`, `generate`, `sync`).
+  - Database-backed migration tracking (Database or JSON storage).
+- **Core Improvements**:
+  - Expanded `@Field()` decorator with schema metadata: `length`, `precision`, `scale`, `unique`, `index`, `columnType`, `defaultValue`, and `comment`.
+  - Added schema generation and introspection capabilities to SQL dialects.
+
+## [1.6.0] - 2025-12-28
+- **Architectural Change**: Migrated from "Values as Parameter" to "Context Object" pattern for SQL generation.
+  - This pattern centralizes query parameters and SQL fragments into a `QueryContext`, ensuring robust placeholder management and preventing out-of-sync parameter indices.
+  - Improved compatibility with PostgreSQL's indexed placeholders ($1, $2, etc.) and complex sub-queries.
+  - Standardized dialect interfaces to operate directly on the `QueryContext` for higher performance and cleaner code.
+- Fixed linter issues and unified type safety for `raw()` SQL snippets across all drivers.
+
+## [1.5.0] - 2025-12-28
+- **BREAKING CHANGE**: Implemented "Sticky Connections" for performance. `Querier` instances now hold their connection until `release()` is explicitly called.
+  - If you manually retrieve a querier via `pool.getQuerier()`, you **MUST** call `await querier.release()` when finished, otherwise connections will leak.
+  - `Repositories` and `pool.transaction(...)` callbacks automatically handle this, so high-level usage remains unchanged.
+- Unified serialization logic: `@Serialized()` decorator is now centralized in `AbstractSqlQuerier`, removing redundant overrides in drivers.
+- Fixed MongoDB consistency: `beginTransaction`, `commitTransaction`, and `rollbackTransaction` are now serialized to prevent race conditions.
+- Fix Cross-Dialect SQL JSON bug by moving PostgreSQL-specific casts to the appropriate dialect.
+- Fix transaction race conditions by serializing transaction lifecycle methods and implementing an internal execution pattern.
+
+## [1.4.16] - 2025-12-28
+
+- Implement a "Serialized Task Queue" at the core of the framework to ensure database connections are thread-safe and race-condition free.
+- Introduce `@Serialized()` decorator to simplify the serialization of database operations across all drivers.
+
+## [1.4.14] - 2025-12-28
+
+- Robust `upsert` implementation across all SQL dialects (PostgreSQL, MySQL, MariaDB, SQLite).
+
+## [1.4.10] - 2025-12-27
+
+- Improve types, tests, migrate from EsLint/Prettier to Biome, and update dependencies.
+
+## [1.4.6] - 2024-11-06
+
+- Update dependencies and improve readme.
+
+## [1.4.5] - 2024-09-26
+
+- Imperative transactions have to be closed manually.
+
+## [1.4.4] - 2024-09-26
+
+- Ensure own connection is always released even if exception occurs.
+- Correct issue when empty or null list is passed to `insertMany` operations.
+
+## [1.4.3] - 2024-09-25
+
+- Ensure the connection is auto-released after `commit` or `rollback` runs.
+- Update dependencies.
+
+## [1.4.2] - 2024-09-20
+
+- Fix projection of `@OneToMany` field when the 'one' side produces empty result.
+- Update dependencies.
+
+## [1.4.1] - 2024-08-21
+
+- Add nukak-maku logo.
+- Update dependencies (functionality keeps the same in this release).
+
+## [1.4.0] - 2024-08-15
+
+- Automatically release the querier unless it is inside a current transaction.
+- Remove unnecessary wrapper for transactions from `AbstractQuerierPool` class.
+
+## [1.3.3] - 2024-08-13
+
+- Improve typings of first inserted ID.
+
+## [1.3.2] - 2024-08-13
+
+- Return the inserted IDs in the response of the queriers' `run` function.
+
+## [1.3.1] - 2024-08-13
+
+- Fix an issue related to the `$where` condition of selected relations missed in the final criteria for `@OneToMany` and `@ManyToMany` relationships.
+
+## [1.3.0] - 2024-08-13
+
+- Add support for `json` and `jsonb` fields. Automatically parse the JSON values when persisting with `JSON.parse` function.
+- Improve type-safety in general.
+- Move `getPersistables` inside dialect for higher reusability.
+- Add support for `vector` fields.
+
+## [1.2.0] - 2024-08-12
+
+- Add support for `raw` in values (previously, it was only supported by `$select` and `$where` operators). Allows safe use of any SQL query/clause as the value in an insert or update operation that shouldn't be automatically escaped by the ORM.
+
+## [1.1.0] - 2024-08-11
+
+- Add support for `upsert` operations.
+- Migrate SQLite package driver from `sqlite3` to `better-sqlite3` for better performance.
+- Make Maria package to use the `RETURNING id` clause to get the inserted IDs.
+
+## [1.0.1] - 2024-08-10
+
+- Rename `$project` operator to `$select` for consistency with most established frameworks so far.
+- Rename `$filter` operator to `$where` for consistency with most established frameworks so far.
+
+## [1.0.0] - 2024-08-10
+
+- Allow to set a field as non-eager (i.e. lazy) with `eager: false` (by default fields are `eager: true`).
+- Allow to set a field as non-updatable (i.e. insertable and read-only) with `updatable: false` (by default fields are `updatable: true`).
+
+## [0.4.0] - 2023-11-06
+
+- Move project inside query parameter [#63](https://github.com/rogerpadilla/nukak/pull/63)
+
+## [0.3.3] - 2023-10-25
+
+- Update usage example in the README.md.
+
+## [0.3.2] - 2023-10-24
+
+- Improve usage examples in the README.md, and make the overview section more concise.
+
+## [0.3.1] - 2023-10-19
+
+1. Remove `$group` and `$having` as they detriment type safety as currently implemented (support may be redesigned later if required).
+2. Improve type safety of `$project` operator.
+3. Improve type safety of `$filter` operator.
+4. Remove projection operators (`$count`, `$min`, `$max`, `$min`, and `$sum`) as they detriment type safety as currently implemented. This can be done via Virtual fields instead as currently supported for better type safety.
+
+## [0.3.0] - 2023-10-18
+
+- Add support for `transaction` operations using a QuerierPool.
+  Automatically wraps the code of the callback inside a transaction, and auto-releases the querier after running.
+- Update dependencies.
+
+  ```ts
+  const ids = await querierPool.transaction(async (querier) => {
+    const data = await querier.findMany(...);
+    const ids = await querier.insertMany(...);
+    return ids;
+  });
+  ```
+
+## [0.2.21] 2023-04-15
+
+- fix(nukak-browser): check if ids are returned before use $in to delete them.
+
+- Reuse community open-source npm packages to escape literal-values according to each DB vendor.
+
+## [0.2.0] 2023-01-02
+
+- Move projection to a new parameter to improve type inference of the results.
+
+- Support dynamic operations while projecting fields, and move `$project` as an independent parameter in the `find*` functions [#55](https://github.com/rogerpadilla/nukak/pull/55).

package/dist/README.md

@@ -0,0 +1,413 @@
+<!-- ![code](/assets/code.webp 'code') -->
+
+[![uql maku](assets/logo.svg)](https://uql.app)
+
+[![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![coverage status](https://coveralls.io/repos/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/r/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
+
+[uql](https://uql.app) is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript, it is designed to be fast, safe, and easy to integrate into any application.
+
+It can run in Node.js, Browser, React Native, Expo, Electron, Deno, Bun, and many more!
+
+Uses a consistent API for distinct databases, including PostgreSQL, MySQL, MariaDB, and SQLite (inspired by MongoDB glorious syntax).
+
+&nbsp;
+
+```ts
+const companyUsers = await userRepository.findMany({
+  $select: { email: true, profile: { $select: { picture: true } } },
+  $where: { email: { $endsWith: '@domain.com' } },
+  $sort: { createdAt: 'desc' },
+  $limit: 100,
+});
+```
+
+&nbsp;
+
+## Why uql?
+
+See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) in medium.com.
+
+&nbsp;
+
+## Features
+
+- **Type-safe and Context-aware queries**: Squeeze the power of `TypeScript` for auto-completion and validation of operators at any depth, [including relations and their fields](https://www.uql.app/docs/querying-relations).
+- **Context-Object SQL Generation**: Uses a sophisticated `QueryContext` pattern to ensure perfectly indexed placeholders ($1, $2, etc.) and robust SQL fragment management, even in the most complex sub-queries.
+- **Unified API across Databases**: Write once, run anywhere. Seamlessly switch between `PostgreSQL`, `MySQL`, `MariaDB`, `SQLite`, and even `MongoDB`.
+- **Serializable JSON Syntax**: Queries can be expressed as `100%` valid `JSON`, allowing them to be easily transported from frontend to backend.
+- **Naming Strategies**: Effortlessly translate between TypeScript `CamelCase` and database `snake_case` (or any custom format) with a pluggable system.
+- **Built-in Serialization**: A centralized task queue and `@Serialized()` decorator ensure database operations are thread-safe and race-condition free by default.
+- **Database Migrations**: Integrated migration system for version-controlled schema management and auto-generation from entities.
+- **High Performance**: Optimized "Sticky Connections" and human-readable, minimal SQL generation.
+- **Modern Architecture**: Pure `ESM` support, designed for `Node.js`, `Bun`, `Deno`, and even mobile/browser environments.
+- **Rich Feature Set**: [Soft-delete](https://uql.app/docs/entities-soft-delete), [virtual fields](https://uql.app/docs/entities-virtual-fields), [repositories](https://uql.app/docs/querying-repository), and automatic handling of `JSON`, `JSONB`, and `Vector` types.
+
+&nbsp;
+
+## 1. Install
+
+1. Install the core package:
+
+   ```sh
+   npm install @uql/core
+   # or
+   bun add @uql/core
+   ```
+
+2. Install one of the specific adapters for your database:
+
+| Database     | Driver           | UQL Adapter    |
+| ------------ | ---------------- | ---------------- |
+| `PostgreSQL` | `pg`             | `uql-postgres` |
+| `SQLite`     | `better-sqlite3` | `uql-sqlite`   |
+| `MariaDB`    | `mariadb`        | `uql-maria`    |
+| `MySQL`      | `mysql2`         | `uql-mysql`    |
+
+&nbsp;
+
+For example, for `Postgres` install the `pg` driver:
+
+```sh
+npm install pg
+# or
+bun add pg
+```
+
+3. Additionally, your `tsconfig.json` may need the following flags:
+
+   ```json
+   "target": "es2022",
+   "experimentalDecorators": true,
+   "emitDecoratorMetadata": true
+   ```
+
+&nbsp;
+
+> **Note**: UQL provides first-class support for **Bun**. It is recommended to use Bun for a significantly faster developer experience.
+
+---
+
+&nbsp;
+
+## 2. Define the entities
+
+Annotate your classes with decorators from `uql/entity`. UQL supports detailed schema metadata for precise DDL generation.
+
+```ts
+import { Entity, Id, Field, OneToOne, OneToMany, ManyToOne, ManyToMany } from '@uql/core/entity';
+import type { Relation } from '@uql/core/type';
+
+@Entity()
+export class User {
+  @Id()
+  id?: string;
+
+  @Field({ length: 100, index: true })
+  name?: string;
+
+  @Field({ unique: true, comment: 'User login email' })
+  email?: string;
+
+  @OneToOne({ entity: () => Profile, mappedBy: 'user', cascade: true })
+  profile?: Relation<Profile>; // Relation<T> handles circular dependencies
+
+  @OneToMany({ entity: () => Post, mappedBy: 'author' })
+  posts?: Relation<Post>[];
+}
+
+@Entity()
+export class Profile {
+  @Id()
+  id?: string;
+
+  @Field()
+  bio?: string;
+
+  @Field({ reference: () => User })
+  userId?: string;
+
+  @OneToOne({ entity: () => User })
+  user?: User;
+}
+
+@Entity()
+export class Post {
+  @Id()
+  id?: number;
+
+  @Field()
+  title?: string;
+
+  @Field({ reference: () => User })
+  authorId?: string;
+
+  @ManyToOne({ entity: () => User })
+  author?: User;
+
+  @ManyToMany({ entity: () => Tag, through: () => PostTag })
+  tags?: Tag[];
+}
+
+@Entity()
+export class Tag {
+  @Id()
+  id?: string;
+
+  @Field()
+  name?: string;
+}
+
+@Entity()
+export class PostTag {
+  @Id()
+  id?: string;
+
+  @Field({ reference: () => Post })
+  postId?: number;
+
+  @Field({ reference: () => Tag })
+  tagId?: string;
+}
+```
+
+&nbsp;
+
+## 3. Setup a querier-pool
+
+A querier-pool can be set in any of the bootstrap files of your app (e.g. in the `server.ts`).
+
+```ts
+// file: ./shared/orm.ts
+import { SnakeCaseNamingStrategy } from '@uql/core';
+import { PgQuerierPool } from 'uql-postgres';
+
+export const querierPool = new PgQuerierPool(
+  {
+    host: 'localhost',
+    user: 'theUser',
+    password: 'thePassword',
+    database: 'theDatabase',
+    min: 1,
+    max: 10,
+  },
+  // Optional extra options.
+  {
+    // Optional, any custom logger function can be passed here (optional).
+    logger: console.debug,
+    // Automatically translate between TypeScript camelCase and database snake_case.
+    // This affects both queries and schema generation.
+    namingStrategy: new SnakeCaseNamingStrategy()
+  },
+);
+```
+
+&nbsp;
+
+## 4. Manipulate the data
+
+UQL provides multiple ways to interact with your data, from low-level `Queriers` to high-level `Repositories`.
+
+### Using Repositories (Recommended)
+
+Repositories provide a clean, Data-Mapper style interface for your entities.
+
+```ts
+import { GenericRepository } from '@uql/core/repository';
+import { User } from './shared/models/index.js';
+import { querierPool } from './shared/orm.js';
+
+// Get a querier from the pool
+const querier = await querierPool.getQuerier();
+
+try {
+  const userRepository = new GenericRepository(User, querier);
+
+  // Advanced querying with relations and virtual fields
+  const users = await userRepository.findMany({
+    $select: {
+      id: true,
+      name: true,
+      profile: ['picture'], // Select specific fields from a 1-1 relation
+      tagsCount: true       // Virtual field (calculated at runtime)
+    },
+    $where: {
+      email: { $iincludes: '@uql/core' }, // Case-insensitive search
+      status: 'active'
+    },
+    $sort: { createdAt: -1 },
+    $limit: 50
+  });
+} finally {
+  // Always release the querier to the pool
+  await querier.release();
+}
+```
+
+### Advanced: Deep Selection & Filtering
+
+UQL's query syntax is context-aware. When you query a relation, the available fields and operators are automatically suggested and validated based on that related entity.
+
+```ts
+import { GenericRepository } from '@uql/core/repository';
+import { User } from './shared/models/index.js';
+import { querierPool } from './shared/orm.js';
+
+const authorsWithPopularPosts = await querierPool.transaction(async (querier) => {
+  const userRepository = new GenericRepository(User, querier);
+
+  return userRepository.findMany({
+    $select: {
+      id: true,
+      name: true,
+      profile: {
+        $select: ['bio'],
+        // Filter related record and enforce INNER JOIN
+        $where: { bio: { $ne: null } },
+        $required: true
+      },
+      posts: {
+        $select: ['title', 'createdAt'],
+        // Filter the related collection directly
+        $where: { title: { $iincludes: 'typescript' } },
+        $sort: { createdAt: -1 },
+        $limit: 5
+      }
+    },
+    $where: {
+      name: { $istartsWith: 'a' }
+    }
+  });
+});
+```
+
+### Advanced: Virtual Fields & Raw SQL
+
+Define complex logic directly in your entities using `raw` functions from `uql/util`. These are highly efficient as they are resolved during SQL generation.
+
+```ts
+import { Entity, Id, Field } from '@uql/core/entity';
+import { raw } from '@uql/core/util';
+import { ItemTag } from './shared/models/index.js';
+
+@Entity()
+export class Item {
+  @Id()
+  id: number;
+
+  @Field()
+  name: string;
+
+  @Field({
+    virtual: raw(({ ctx, dialect, escapedPrefix }) => {
+      ctx.append('(');
+      dialect.count(ctx, ItemTag, {
+        $where: {
+          itemId: raw(({ ctx }) => ctx.append(`${escapedPrefix}.id`))
+        }
+      }, { autoPrefix: true });
+      ctx.append(')');
+    })
+  })
+  tagsCount?: number;
+}
+```
+
+### Thread-Safe Transactions
+
+UQL ensures your operations are serialized and thread-safe.
+
+```ts
+import { User, Profile } from './shared/models/index.js';
+import { querierPool } from './shared/orm.js';
+
+const result = await querierPool.transaction(async (querier) => {
+  const user = await querier.findOne(User, { $where: { email: '...' } });
+  const profileId = await querier.insertOne(Profile, { userId: user.id, ... });
+  return { userId: user.id, profileId };
+});
+// Connection is automatically released after transaction
+```
+
+&nbsp;
+
+## 5. Migrations & Synchronization
+
+UQL includes a robust migration system and an "Entity-First" synchronization engine built directly into the core.
+
+### 1. Create Configuration
+
+Create a `uql.config.ts` file in your project root:
+
+```typescript
+import { PgQuerierPool } from 'uql-postgres';
+import { User, Post } from './src/entities/index.js';
+
+export default {
+  querierPool: new PgQuerierPool({ /* config */ }),
+  dialect: 'postgres',
+  entities: [User, Post],
+  migrationsPath: './migrations',
+};
+```
+
+### 2. Manage via CLI
+
+UQL provides a dedicated CLI tool for migrations.
+
+```bash
+# Generate a migration by comparing entities vs database
+npx uql-migrate generate:entities initial_schema
+# or
+bunx uql-migrate generate:entities initial_schema
+
+# Run pending migrations
+npx uql-migrate up
+# or
+bunx uql-migrate up
+
+# Rollback the last migration
+npx uql-migrate down
+# or
+bunx uql-migrate down
+
+# Check status
+npx uql-migrate status
+# or
+bunx uql-migrate status
+```
+
+### 3. Entity-First Synchronization (Development)
+
+In development, you can use `autoSync` to automatically keep your database in sync with your entities without manual migrations. It is **safe by default**, meaning it only adds missing tables and columns.
+
+```ts
+import { Migrator } from '@uql/core/migrate';
+import { querierPool } from './shared/orm.js';
+
+const migrator = new Migrator(querierPool);
+await migrator.autoSync({ logging: true });
+```
+
+Check out the full [documentation](https://uql.app/docs/migrations) for detailed CLI commands and advanced usage.
+
+&nbsp;
+
+Check out the full documentation at [uql.app](https://uql.app) for details on:
+- [Complex Logical Operators](https://uql.app/docs/querying-logical-operators)
+- [Relationship Mapping (1-1, 1-M, M-M)](https://uql.app/docs/querying-relations)
+- [Soft Deletes & Auditing](https://uql.app/docs/entities-soft-delete)
+- [Database Migration & Syncing](https://uql.app/docs/migrations)
+
+---
+
+## 🛠 Deep Dive: Tests & Technical Resources
+
+For those who want to see the "engine under the hood," check out these resources in the source code:
+
+- **Entity Mocks**: See how complex entities and virtual fields are defined in [entityMock.ts](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/test/entityMock.ts).
+- **Core Dialect Logic**: The foundation of our context-aware SQL generation in [abstractSqlDialect.ts](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/dialect/abstractSqlDialect.ts).
+- **Comprehensive Test Suite**:
+  - [Abstract SQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/dialect/abstractSqlDialect-spec.ts): The base test suite shared by all dialects.
+  - [PostgreSQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/postgres/src/postgresDialect.spec.ts) | [MySQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/mysql/src/mysqlDialect.spec.ts) | [SQLite Spec](https://github.com/rogerpadilla/uql/blob/main/packages/sqlite/src/sqliteDialect.spec.ts).
+  - [Querier Integration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/querier/abstractSqlQuerier-spec.ts): Testing the interaction between SQL generation and connection management.
+  - [MongoDB Migration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/uql/src/migrate/migrator-mongo.it.ts): Integration tests ensuring correct collection and index synchronization for MongoDB.

package/dist/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql.app",
   "description": "One Language. Frontend to Backend.",
   "license": "MIT",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -36,7 +36,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "copyfiles": "copyfiles -f package.json ../README.md ../CHANGELOG.md dist",
+    "copyfiles": "copyfiles -f package.json ../../README.md ../../CHANGELOG.md dist",
     "compile.browser": "bunchee --clean false --no-dts ./src/browser/index.ts --sourcemap -o ./dist/browser/uql-browser.min.js",
     "build": "bun run clean && tsc -b tsconfig.build.json && bun run compile.browser && bun run copyfiles",
     "start": "tsc --watch",

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql.app",
   "description": "One Language. Frontend to Backend.",
   "license": "MIT",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -36,7 +36,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "copyfiles": "copyfiles -f package.json ../README.md ../CHANGELOG.md dist",
+    "copyfiles": "copyfiles -f package.json ../../README.md ../../CHANGELOG.md dist",
     "compile.browser": "bunchee --clean false --no-dts ./src/browser/index.ts --sourcemap -o ./dist/browser/uql-browser.min.js",
     "build": "bun run clean && tsc -b tsconfig.build.json && bun run compile.browser && bun run copyfiles",
     "start": "tsc --watch",
@@ -127,5 +127,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "47f2055cf30ab5655ac57ba4278e8c7b4541db0b"
+  "gitHead": "0105a041059fcfd55222bdf1d7ddb01fad984a36"
 }