@kubun/store-graph 0.10.2 → 0.12.0

package/lib/query-builder.js

@@ -1 +1,370 @@
-import{parseCursor as e}from"./cursor.js";function t(e=50){return Math.min(e,100)}function r(e,t){let r=e.ref("data","->>");for(let e of t)r=r.key(e);return r}export function aggregateFieldName(e){return e.join(".")}export function applyAggregateSelections(e,t,n){let a=[];for(let l of t){let t=aggregateFieldName(l.keys),o=r(e,l.keys),u=l.numeric?n.numericCast(o):o;switch(l.op){case"sum":a.push(e.fn.sum(u).as(`sum_${t}`));break;case"average":a.push(e.fn.sum(u).as(`sum_${t}`)),a.push(e.fn.count(u).as(`count_${t}`));break;case"min":a.push(e.fn.min(u).as(`min_${t}`));break;case"max":a.push(e.fn.max(u).as(`max_${t}`));break;default:throw Error(`Invalid aggregate op: ${l.op}`)}}return a}export function groupKeyAlias(e){return`key_${e.join(".")}`}export function applyGroupBySelections(e,t){let n=[],a=[];for(let l of t){let t=r(e,l.keys);n.push(t.as(groupKeyAlias(l.keys))),a.push(t)}return{selections:n,expressions:a}}function n(e){let t=[],r=e;do{let[e,n]=Object.entries(r)[0];if(t.push(e),"string"==typeof n)return{keys:t,direction:n};r=n}while(null!=r)throw Error("Could not extract field entry")}function a(e,t=!1){return t?"asc"===e?"desc":"asc":e}export function applyPagination(a,l,o=[]){let{first:u,last:i,before:s,after:c}=l;if(null!=u){let l=t(u);return[function(t,a,l,o){let u=t;if(null!=l){let{id:t,ts:a,values:i}=e(l);null!=a?u=u.where(e=>e.or([e("created_at",">",a),e("created_at","=",a).and("id",">",t)])):null!=i&&(u=u.where(e=>{let a=[];for(let l of o){let o=n(l),u=i[o.keys.join(".")];if(null==u)continue;let s=r(e,o.keys);a.push(e.or([e(s,"asc"===o.direction?">":"<",u),e(s,"=",u).and("id",">",t)]))}return e.and(a)}))}return u.orderBy("created_at","asc").limit(a)}(a,l+1,c,o),l]}if(null!=i){let l=t(i);return[function(t,a,l,o){let u=t;if(null!=l){let{id:t,ts:a,values:i}=e(l);null!=a?u=u.where(e=>e.or([e("created_at","<",a),e("created_at","=",a).and("id","<",t)])):null!=i&&(u=u.where(e=>{let a=[];for(let l of o){let o=n(l),u=i[o.keys.join(".")];if(null==u)continue;let s=r(e,o.keys);a.push(e.or([e(s,"asc"===o.direction?"<":">",u),e(s,"=",u).and("id",">",t)]))}return e.and(a)}))}return u.orderBy("created_at","desc").limit(a)}(a,l+1,s,o),l]}let f=t();return[a.orderBy("created_at","asc").limit(f+1),f]}export function applyDocumentFilter(e,t,r=[],n){let a=Object.entries(t);if(1!==a.length)throw Error("Invalid document filter");let[l,o]=a[0];switch(l){case"where":var u,i,s,c;let f;return u=e,i=o,s=r,c=n,f=Object.entries(i).map(([e,t])=>applyValueFilter(u,[...s,e],t,c)),u.and(f);case"and":return e.and(o.map(t=>applyDocumentFilter(e,t,r,n)));case"or":return e.or(o.map(t=>applyDocumentFilter(e,t,r,n)));case"not":return e.not(applyDocumentFilter(e,o,r,n));default:throw Error(`Invalid document filter type: ${l}`)}}export function applyValueFilter(e,t,n,a){let l=Object.entries(n);if(1!==l.length)throw Error("Invalid value filter");let o=r(e,t),[u,i]=l[0],s=a??(e=>e);switch(u){case"isNull":return e(o,!0===i?"is":"is not",null);case"equalTo":return e(o,"=",s(i));case"notEqualTo":return e(o,"!=",s(i));case"in":return e(o,"in",i.map(s));case"notIn":return e(o,"not in",i.map(s));case"lessThan":return e(o,"<",s(i));case"lessThanOrEqualTo":return e(o,"<=",s(i));case"greaterThan":return e(o,">",s(i));case"greaterThanOrEqualTo":return e(o,">=",s(i));default:throw Error(`Invalid value filter type: ${u}`)}}export function applyDocumentOrderBy(e,t=[],n=!1){if(0===t.length)return[e.orderBy("created_at",a("asc",n)),null];let o=e,u=[];for(let e of t){let[t,i]=function e(t,n,o,u=[]){let i=Object.entries(n);if(1!==i.length)throw Error("Invalid order by field");let[s,c]=i[0],f=[...u,s],p=l[s];return null!=p?[t.orderBy(p,a(c,o)),f]:"string"==typeof c?[t.orderBy(e=>r(e,f),a(c,o)),f]:e(t,c,o,f)}(o,e,n);o=t,u.push(i)}return[o,u]}let l={_createdAt:"created_at",_owner:"owner"};
+import { sql } from 'kysely';
+import { parseCursor } from './cursor.js';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 100;
+function getLimit(value = DEFAULT_LIMIT) {
+    return Math.min(value, MAX_LIMIT);
+}
+function getKeyPath(eb, keys) {
+    let keyPath = eb.ref('data', '->>');
+    for (const key of keys){
+        keyPath = keyPath.key(key);
+    }
+    return keyPath;
+}
+export function aggregateFieldName(keys) {
+    return keys.join('.');
+}
+export function applyAggregateSelections(eb, specs, adapter) {
+    const selections = [];
+    for (const spec of specs){
+        const field = aggregateFieldName(spec.keys);
+        const raw = getKeyPath(eb, spec.keys);
+        const value = spec.numeric ? adapter.numericCast(raw) : raw;
+        switch(spec.op){
+            case 'sum':
+                selections.push(eb.fn.sum(value).as(`sum_${field}`));
+                break;
+            case 'average':
+                selections.push(eb.fn.sum(value).as(`sum_${field}`));
+                selections.push(eb.fn.count(value).as(`count_${field}`));
+                break;
+            case 'min':
+                selections.push(eb.fn.min(value).as(`min_${field}`));
+                break;
+            case 'max':
+                selections.push(eb.fn.max(value).as(`max_${field}`));
+                break;
+            default:
+                throw new Error(`Invalid aggregate op: ${spec.op}`);
+        }
+    }
+    return selections;
+}
+export function groupKeyAlias(keys) {
+    return `key_${keys.join('.')}`;
+}
+// Builds the aliased group-key select expressions plus the matching GROUP BY
+// expressions. Grouping is on the raw text extraction (no numeric cast): equality
+// bucketing is correct on text, and the JSON encoder serialises a given value
+// identically across model tables.
+export function applyGroupBySelections(eb, groupBy) {
+    const selections = [];
+    const expressions = [];
+    for (const group of groupBy){
+        const raw = getKeyPath(eb, group.keys);
+        selections.push(raw.as(groupKeyAlias(group.keys)));
+        expressions.push(raw);
+    }
+    return {
+        selections,
+        expressions
+    };
+}
+function getOrderByFieldEntry(field) {
+    const keys = [];
+    let current = field;
+    do {
+        const [key, value] = Object.entries(current)[0];
+        keys.push(key);
+        if (typeof value === 'string') {
+            return {
+                keys,
+                direction: value
+            };
+        }
+        current = value;
+    }while (current != null)
+    throw new Error('Could not extract field entry');
+}
+function orderByDirection(direction, isReversed = false) {
+    return isReversed ? direction === 'asc' ? 'desc' : 'asc' : direction;
+}
+export function applyPagination(query, args, orderBy = [], coerce) {
+    const { first, last, before, after } = args;
+    if (first != null) {
+        const limit = getLimit(first);
+        return [
+            applyForwardPagination(query, limit + 1, after, orderBy, coerce),
+            limit
+        ];
+    }
+    if (last != null) {
+        const limit = getLimit(last);
+        return [
+            applyBackwardPagination(query, limit + 1, before, orderBy, coerce),
+            limit
+        ];
+    }
+    const limit = getLimit();
+    return [
+        query.limit(limit + 1),
+        limit
+    ];
+}
+// Resolves an ordered field to the same SQL expression the ORDER BY uses, so the
+// keyset predicate compares against the exact column being sorted. Known fields map
+// to real columns (created_at, owner); everything else is a JSON path extraction.
+function orderByFieldExpression(eb, keys) {
+    const knownField = knownFieldColumn(keys);
+    if (knownField != null) {
+        return eb.ref(knownField);
+    }
+    return getKeyPath(eb, keys);
+}
+// The term selecting rows that strictly advance past the cursor on this field (prior
+// fields equal). Encodes the null bucket per SQL-standard position:
+//   ascending (nulls last):  cursor non-null -> f > v OR f IS NULL ; cursor null -> nothing
+//   descending (nulls first): cursor non-null -> f < v             ; cursor null -> f IS NOT NULL
+function advanceTerm(eb, field) {
+    if (field.value == null) {
+        // Ascending nulls sort last, so nothing advances past a null cursor on this field.
+        return field.ascending ? sql`1 = 0` : eb(field.expr, 'is not', null);
+    }
+    if (field.ascending) {
+        return eb.or([
+            eb(field.expr, '>', field.value),
+            eb(field.expr, 'is', null)
+        ]);
+    }
+    return eb(field.expr, '<', field.value);
+}
+// The term selecting rows that tie this field with the cursor (continue to the next
+// field). A null cursor value ties with other null rows.
+function equalTerm(eb, field) {
+    return field.value == null ? eb(field.expr, 'is', null) : eb(field.expr, '=', field.value);
+}
+// Builds the lexicographic keyset predicate that pairs with an ORDER BY whose terminal
+// column is `id`. For ORDER BY (f1..fn, id) the rows strictly after the cursor are:
+//   advance(f1)
+//   OR (eq(f1) AND advance(f2))
+//   ...
+//   OR (eq(f1) AND ... AND eq(fn) AND id idCmp idCursor)
+// The tie-break on `id` guarantees no duplicate or skipped row when ordered values
+// repeat. Null ordered values stay in the chain (tagged via `nullKeys`) and sort in
+// SQL-standard position, so concatenated pages match the full ordered set across the
+// null boundary. `forward` true is a forward scan; false flips every field's effective
+// direction (and thus its null position) for a reversed scan.
+function buildKeysetPredicate(eb, orderBy, values, nullKeys, id, forward, coerce) {
+    // Cursor comparison values must be coerced the same way filter values are: a JSON
+    // path extraction (`data ->> field`) yields adapter-specific text/integer forms
+    // (e.g. 1/0 for booleans on SQLite), so an uncoerced cursor value would misfire and
+    // drift pages. Known-column fields (created_at, owner) are not JSON-extracted.
+    const c = coerce ?? ((v)=>v);
+    const nullSet = new Set(nullKeys);
+    const fields = [];
+    for (const orderByField of orderBy){
+        const entry = getOrderByFieldEntry(orderByField);
+        const key = entry.keys.join('.');
+        const ascending = entry.direction === 'asc' === forward;
+        const isKnownField = knownFieldColumn(entry.keys) != null;
+        // A key absent from both buckets (stale or malformed cursor) is treated as the null
+        // bucket rather than binding an undefined comparison value.
+        const isNull = nullSet.has(key) || !(key in values);
+        const rawValue = values[key];
+        fields.push({
+            expr: orderByFieldExpression(eb, entry.keys),
+            value: isNull ? null : isKnownField ? rawValue : c(rawValue),
+            ascending
+        });
+    }
+    const idCmp = forward ? '>' : '<';
+    const clauses = [];
+    for(let level = 0; level < fields.length; level += 1){
+        const conjuncts = [];
+        for(let prior = 0; prior < level; prior += 1){
+            conjuncts.push(equalTerm(eb, fields[prior]));
+        }
+        conjuncts.push(advanceTerm(eb, fields[level]));
+        clauses.push(eb.and(conjuncts));
+    }
+    const tieBreak = [];
+    for (const field of fields){
+        tieBreak.push(equalTerm(eb, field));
+    }
+    tieBreak.push(eb('id', idCmp, id));
+    clauses.push(eb.and(tieBreak));
+    return eb.or(clauses);
+}
+function applyForwardPagination(queryBuilder, limit, after, orderBy, coerce) {
+    let query = queryBuilder;
+    if (after != null) {
+        const { id, ts, values, nullKeys } = parseCursor(after);
+        if (ts != null) {
+            query = query.where((eb)=>{
+                return eb.or([
+                    eb('created_at', '>', ts),
+                    eb('created_at', '=', ts).and('id', '>', id)
+                ]);
+            });
+        } else if (values != null || nullKeys != null) {
+            query = query.where((eb)=>buildKeysetPredicate(eb, orderBy, values ?? {}, nullKeys ?? [], id, true, coerce));
+        }
+    }
+    return query.limit(limit);
+}
+function applyBackwardPagination(queryBuilder, limit, before, orderBy, coerce) {
+    let query = queryBuilder;
+    if (before != null) {
+        const { id, ts, values, nullKeys } = parseCursor(before);
+        if (ts != null) {
+            query = query.where((eb)=>{
+                return eb.or([
+                    eb('created_at', '<', ts),
+                    eb('created_at', '=', ts).and('id', '<', id)
+                ]);
+            });
+        } else if (values != null || nullKeys != null) {
+            query = query.where((eb)=>buildKeysetPredicate(eb, orderBy, values ?? {}, nullKeys ?? [], id, false, coerce));
+        }
+    }
+    return query.limit(limit);
+}
+export function applyDocumentFilter(eb, filter, path = [], coerce) {
+    const entries = Object.entries(filter);
+    if (entries.length !== 1) {
+        throw new Error('Invalid document filter');
+    }
+    const [type, value] = entries[0];
+    switch(type){
+        case 'where':
+            return applyObjectFilter(eb, value, path, coerce);
+        case 'and':
+            return eb.and(value.map((filter)=>{
+                return applyDocumentFilter(eb, filter, path, coerce);
+            }));
+        case 'or':
+            return eb.or(value.map((filter)=>{
+                return applyDocumentFilter(eb, filter, path, coerce);
+            }));
+        case 'not':
+            return eb.not(applyDocumentFilter(eb, value, path, coerce));
+        default:
+            throw new Error(`Invalid document filter type: ${type}`);
+    }
+}
+function applyObjectFilter(eb, filter, path, coerce) {
+    const criteria = Object.entries(filter).map(([fieldName, valueFilter])=>{
+        // TODO: check if value filter or nested object filter should be applied
+        // for nested object, check if embedded or related object
+        return applyValueFilter(eb, [
+            ...path,
+            fieldName
+        ], valueFilter, coerce);
+    });
+    return eb.and(criteria);
+}
+export function applyValueFilter(eb, keys, filter, coerce) {
+    const entries = Object.entries(filter);
+    if (entries.length !== 1) {
+        throw new Error('Invalid value filter');
+    }
+    const fieldName = getKeyPath(eb, keys);
+    const [type, value] = entries[0];
+    const c = coerce ?? ((v)=>v);
+    switch(type){
+        case 'isNull':
+            return eb(fieldName, value === true ? 'is' : 'is not', null);
+        case 'equalTo':
+            return eb(fieldName, '=', c(value));
+        case 'notEqualTo':
+            return eb(fieldName, '!=', c(value));
+        case 'in':
+            return eb(fieldName, 'in', value.map(c));
+        case 'notIn':
+            return eb(fieldName, 'not in', value.map(c));
+        case 'lessThan':
+            return eb(fieldName, '<', c(value));
+        case 'lessThanOrEqualTo':
+            return eb(fieldName, '<=', c(value));
+        case 'greaterThan':
+            return eb(fieldName, '>', c(value));
+        case 'greaterThanOrEqualTo':
+            return eb(fieldName, '>=', c(value));
+        default:
+            throw new Error(`Invalid value filter type: ${type}`);
+    }
+}
+export function applyDocumentOrderBy(queryBuilder, adapter, orderBy = [], isReverse = false) {
+    // `id` is the terminal sort column on every path so the cursor keyset can tie-break
+    // on a column that is actually part of the ORDER BY. Without it, repeated ordered
+    // values would let pagination duplicate or skip rows. `id` sorts in the scan
+    // direction (reversed when isReverse) so the keyset comparator stays consistent.
+    const idDirection = orderByDirection('asc', isReverse);
+    if (orderBy.length === 0) {
+        return [
+            queryBuilder.orderBy('created_at', idDirection).orderBy('id', idDirection),
+            null
+        ];
+    }
+    let query = queryBuilder;
+    const paths = [];
+    for (const entry of orderBy){
+        const [newQuery, path] = applyOrderByField(query, adapter, entry, isReverse);
+        query = newQuery;
+        paths.push(path);
+    }
+    query = query.orderBy('id', idDirection);
+    return [
+        query,
+        paths
+    ];
+}
+// Ordered fields that map directly to non-null table columns instead of a JSON-path
+// extraction out of `data`. Keys match the GraphQL orderBy field names; values are the
+// physical column names. Cursor construction must read these from the row column, not
+// from `data`, or the ordered value comes back undefined and the keyset predicate drops
+// every row past the first page.
+export const KNOWN_FIELDS = {
+    _createdAt: 'created_at',
+    _docOwner: 'owner'
+};
+export function knownFieldColumn(keys) {
+    if (keys.length !== 1) return undefined;
+    return KNOWN_FIELDS[keys[0]];
+}
+function applyOrderByField(query, adapter, orderBy, isReverse, path = []) {
+    const entries = Object.entries(orderBy);
+    if (entries.length !== 1) {
+        throw new Error('Invalid order by field');
+    }
+    const [key, value] = entries[0];
+    const keys = [
+        ...path,
+        key
+    ];
+    const knownField = knownFieldColumn(keys);
+    if (knownField != null) {
+        // Known columns (created_at, owner) are non-null, so no null positioning is needed.
+        return [
+            query.orderBy(knownField, orderByDirection(value, isReverse)),
+            keys
+        ];
+    }
+    if (typeof value !== 'string') {
+        return applyOrderByField(query, adapter, value, isReverse, keys);
+    }
+    // JSON-extracted fields can be null. Sort them in SQL-standard null position (last on
+    // ascending, first on descending) on every adapter via the adapter's null-ordering term.
+    const direction = orderByDirection(value, isReverse);
+    const probe = adapter.nullOrdering(sql`1`, direction);
+    if (probe.kind === 'lead') {
+        // Prepend an ascending rank column that buckets nulls last/first, then sort on the
+        // field itself. The rank expression embeds the field's own JSON-path extraction.
+        return [
+            query.orderBy((eb)=>adapterLeadExpression(adapter, eb, keys, direction), 'asc').orderBy((eb)=>getKeyPath(eb, keys), direction),
+            keys
+        ];
+    }
+    return [
+        query.orderBy((eb)=>getKeyPath(eb, keys), (ob)=>direction === 'asc' ? ob.asc().nullsLast() : ob.desc().nullsFirst()),
+        keys
+    ];
+}
+function adapterLeadExpression(adapter, eb, keys, direction) {
+    const term = adapter.nullOrdering(getKeyPath(eb, keys), direction);
+    if (term.kind !== 'lead') {
+        throw new Error('Expected a leading null-ordering term');
+    }
+    return term.expression;
+}

package/lib/tables.d.ts

@@ -10,6 +10,7 @@ export type DocumentTable<Data extends DocumentData = DocumentData> = {
     model: string;
     data: JSONValueColumn<Data> | null;
     field_hlcs: JSONValueColumn<Record<string, string>> | null;
+    field_values: JSONValueColumn<Record<string, unknown>> | null;
     unique: Uint8Array;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;
@@ -98,6 +99,10 @@ export type UserModelAccessDefaultTable = {
     allowed_dids: JSONValueColumn<Array<string>> | null;
     allowed_circles: JSONValueColumn<Array<string>> | null;
     allowed_groups: JSONValueColumn<Array<string>> | null;
+    /** LWW anchor for replicated rules. Null for rows never stamped by a broadcast. */
+    hlc: string | null;
+    /** Retained-tombstone marker: 1 = removed, 0/null = active. */
+    removed: number | null;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;
 };
@@ -111,6 +116,30 @@ export type CatalogTable = {
     description: string;
     filter_criteria: JSONValueColumn<CatalogFilterCriteria>;
     hlc: string;
+    /**
+     * Local-only sync activation: 1 = active (scopes sync), 0/null = known (a
+     * discovered catalog that has not been activated). Insert-optional; own
+     * catalogs are created active, discovered ones arrive known.
+     */
+    active: ColumnType<number | null, number | null | undefined, number | null>;
+    /**
+     * Provenance: the group this catalog was first discovered from, null for own
+     * catalogs. First-discovery only — never overwritten on re-discovery.
+     */
+    source_group_id: ColumnType<string | null, string | null | undefined, string | null>;
+    /**
+     * Provenance: the circle whose `catalog_ids` first referenced this catalog
+     * (set only for invite-seeded discovery), null otherwise. First-discovery only.
+     */
+    source_circle_id: ColumnType<string | null, string | null | undefined, string | null>;
+    /**
+     * The creator-signed `catalog:set` token that authenticated this catalog: own
+     * catalogs sign it at creation, discovered ones store the verified token that
+     * delivered them. Forwarded verbatim in invite seeds so a joiner re-verifies
+     * creator-binding (`ownerDID === iss`) with the same helper the broadcast
+     * receive path uses. Null for rows that predate token capture.
+     */
+    signed_token: ColumnType<string | null, string | null | undefined, string | null>;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;
 };
@@ -141,6 +170,13 @@ export type CreateDocumentParams = DocumentParams & {
 export type SaveDocumentParams = DocumentParams & {
     existing: DocumentNode;
 };
+/** One cluster's registration, written with the graph that deploys it. */
+export type CreateGraphCluster = {
+    /** The cluster definition, stored verbatim for a peer to ship onward. */
+    definition: unknown;
+    /** modelID → index within the cluster. */
+    models: Record<string, number>;
+};
 export type CreateGraphParams = {
     aliases?: Record<string, string>;
     extensionSDL?: string;
@@ -149,6 +185,13 @@ export type CreateGraphParams = {
     pluginConfig?: Record<string, Record<string, unknown>>;
     record: DocumentModelsRecord;
     search?: SearchConfig;
+    /**
+     * Clusters to register in the SAME transaction as the graph. The cluster a
+     * model was deployed in is what lets a peer ship that model's definition to a
+     * device that lacks it, so a graph written without its clusters is one that
+     * works locally and cannot be synced to a device that has never seen it.
+     */
+    clusters?: Record<string, CreateGraphCluster>;
 };
 export type AddDocumentModelParams = {
     id: string;

package/lib/tables.js

@@ -1 +1 @@
-export{};
+export { };

package/package.json

@@ -1,40 +1,40 @@
 {
   "name": "@kubun/store-graph",
-  "version": "0.10.2",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@enkaku/codec": "^0.16.0",
-    "kysely": "^0.29.2",
-    "@kubun/db": "^0.10.0",
-    "@kubun/id": "^0.10.0",
-    "@kubun/db-adapter": "^0.10.0",
-    "@kubun/protocol": "^0.10.0"
+    "@sozai/codec": "^0.4.0",
+    "kysely": "^0.29.4",
+    "@kubun/db": "^0.12.0",
+    "@kubun/db-adapter": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/id": "^0.12.0"
   },
   "devDependencies": {
-    "@testcontainers/postgresql": "^12.0.1",
-    "@kubun/db-better-sqlite": "^0.10.0",
-    "@kubun/db-postgres": "^0.10.0"
+    "@testcontainers/postgresql": "^12.1.0",
+    "@kubun/db-better-sqlite": "^0.12.0",
+    "@kubun/db-postgres": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }