kitcn 0.17.2 → 0.17.4

package/dist/watcher.mjs

@@ -1,12 +1,24 @@
 #!/usr/bin/env node
-import { At as PARSE_SNAPSHOT_SUFFIX, Dt as generateMeta, F as resolveRunDeps, Ot as getConvexConfig, j as resolveConfiguredBackend, kt as logger, q as withLocalCodegenEnv } from "./backend-core-KwJ5FZgj.mjs";
+import { a as generateMeta, c as PARSE_SNAPSHOT_SUFFIX, i as resolveConfiguredBackend, n as withLocalCodegenEnv, o as getConvexConfig, r as loadCliConfig, s as logger } from "./local-env-DykABjCt.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 //#region src/cli/watcher.ts
+function getConvexRoot(functionsDir) {
+	const projectDir = path.resolve(process.cwd());
+	const relativeFunctionsDir = path.relative(projectDir, functionsDir);
+	return relativeFunctionsDir.includes(path.sep) && relativeFunctionsDir !== ".." && !relativeFunctionsDir.startsWith(`..${path.sep}`) && !path.isAbsolute(relativeFunctionsDir) ? path.dirname(functionsDir) : functionsDir;
+}
 function getWatchRoots(functionsDir) {
-	const convexDir = path.dirname(functionsDir);
-	return [functionsDir, path.join(convexDir, "routers")];
+	const functions = path.resolve(functionsDir);
+	const convexRoot = getConvexRoot(functions);
+	const roots = [
+		functions,
+		path.join(convexRoot, "routers"),
+		path.join(convexRoot, "lib"),
+		path.join(convexRoot, "shared")
+	];
+	return roots.filter((root, index) => roots.indexOf(root) === index && !roots.some((other) => root.startsWith(`${other}${path.sep}`)));
 }
 function parseWatcherBackendEnv(value) {
 	if (value === "convex" || value === "concave") return value;
@@ -47,10 +59,9 @@ function shouldIgnoreWatchPath(watchedPath, functionsDir, outputFile) {
 	return normalizedPath.endsWith(".runtime.ts") || normalizedPath.endsWith(PARSE_SNAPSHOT_SUFFIX);
 }
 async function runWatcherCodegen(params, deps = {}) {
-	const resolveRunDepsFn = deps.resolveRunDeps ?? resolveRunDeps;
 	const resolveConfiguredBackendFn = deps.resolveConfiguredBackendFn ?? resolveConfiguredBackend;
-	const { execa: execaFn, generateMeta: generateMetaFn, loadCliConfig: loadCliConfigFn } = resolveRunDepsFn();
-	const config = loadCliConfigFn(params.configPath);
+	const generateMetaFn = deps.generateMeta ?? generateMeta;
+	const config = (deps.loadCliConfig ?? loadCliConfig)(params.configPath);
 	const backend = resolveConfiguredBackendFn({
 		backendArg: params.backendArg,
 		config
@@ -78,7 +89,7 @@ async function runWatcherCodegen(params, deps = {}) {
 	if (params.sharedDir) args.push("--api", params.sharedDir);
 	if (params.configPath) args.push("--config", params.configPath);
 	if (params.debug) args.push("--debug");
-	const result = await execaFn(runtime, args, {
+	const result = await (deps.execa ?? (await import("execa")).execa)(runtime, args, {
 		cwd: process.cwd(),
 		reject: false,
 		stdio: "pipe"

package/dist/{where-clause-compiler-BRhLW1dp.d.ts → where-clause-compiler-BnVpjKn6.d.ts}

@@ -2275,6 +2275,11 @@ declare class ConvexDeleteBuilder<TTable extends ConvexTable<any>, TReturning ex
   private scheduledDelayMs?;
   private executionModeOverride?;
   private paginateConfig?;
+  private _returningCountLoader?;
+  /**
+   * One loader per statement: the table config, edge filter and aggregate-index
+   * readiness memo are invariant across the affected rows.
+   */
   private _loadReturningCount;
   constructor(db: GenericDatabaseWriter<any>, table: TTable);
   where(expression: FilterExpression$1<boolean>): ConvexDeleteBuilder<TTable, TReturning, TMode, true>;
@@ -2319,6 +2324,11 @@ declare class ConvexInsertBuilder<TTable extends ConvexTable<any>, TReturning ex
   private returningFields?;
   private conflictConfig?;
   private allowFullScanFlag;
+  private _returningCountLoader?;
+  /**
+   * One loader per statement: the table config, edge filter and aggregate-index
+   * readiness memo are invariant across the affected rows.
+   */
   private _loadReturningCount;
   constructor(db: GenericDatabaseWriter<any>, table: TTable);
   values(values: InsertValue<TTable> | InsertValue<TTable>[]): this;
@@ -2411,12 +2421,38 @@ declare class GelRelationalQuery<TSchema extends TablesRelationalConfig, TTableC
     readonly result: TResult;
   };
   private allowFullScan;
+  /**
+   * Set synchronously by the first `execute()`. Later executions run on a fresh
+   * instance instead, which is what keeps execution-scoped state from leaking
+   * between two awaits of the same query object.
+   */
+  private _executionClaimed;
+  /**
+   * Scoped to one execution, because `_executionClaimed` diverts every later
+   * execution to its own instance. Within a run, every `_applyRlsSelectFilter`
+   * call shares it, including the streaming sites that pass a single row at a
+   * time — those would otherwise re-resolve the whole policy set per row.
+   *
+   * SECURITY: a resolved policy expression can embed database state that a
+   * later write invalidates, so it must never outlive the execution that
+   * resolved it.
+   */
+  private readonly _rlsPolicyResolution;
+  /**
+   * Assigned in the constructor so callers that run many short-lived query
+   * instances against the same tables (mutation `returning({ _count })`) can
+   * share one readiness memo instead of re-probing per instance.
+   */
   private readonly _countIndexReadinessByKey;
-  private readonly _aggregateIndexReadinessByKey;
+  /**
+   * Index readiness is a probe memo, not execution state, so `_forExecution`
+   * hands it to the next run rather than re-probing.
+   */
+  private _aggregateIndexReadinessByKey;
   constructor(schema: TSchema, tableConfig: TTableConfig, edgeMetadata: EdgeMetadata[], db: GenericDatabaseReader<any>, config: DBQueryConfig<'one' | 'many', boolean, TSchema, TTableConfig>, mode: 'many' | 'first' | 'firstOrThrow' | 'count' | 'aggregate' | 'groupBy', _allEdges?: EdgeMetadata[] | undefined, // M6.5 Phase 2: All edges for nested loading
   rls?: RlsContext | undefined, relationLoading?: {
     concurrency?: number;
-  } | undefined, vectorSearchProvider?: VectorSearchProvider | undefined, configuredIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined);
+  } | undefined, vectorSearchProvider?: VectorSearchProvider | undefined, configuredIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined, countIndexReadiness?: Map<string, Promise<void>>);
   private _usesSystemCreatedAtAlias;
   private _assertNoLegacyPublicFieldName;
   private _normalizePublicFieldName;
@@ -2564,6 +2600,11 @@ declare class GelRelationalQuery<TSchema extends TablesRelationalConfig, TTableC
   private _coerceGroupByConfig;
   private _buildAggregateMetricConfig;
   private _executeGroupBy;
+  /**
+   * A second instance of the same query: identical configuration, its own
+   * execution-scoped state, the same index-readiness memos.
+   */
+  private _forExecution;
   /**
    * Execute the query and return results
    * Phase 4 implementation with WhereClauseCompiler integration
@@ -2933,6 +2974,11 @@ declare class ConvexUpdateBuilder<TTable extends ConvexTable<any>, TReturning ex
   private allowFullScanFlag;
   private paginateConfig?;
   private executionModeOverride?;
+  private _returningCountLoader?;
+  /**
+   * One loader per statement: the table config, edge filter and aggregate-index
+   * readiness memo are invariant across the affected rows.
+   */
   private _loadReturningCount;
   constructor(db: GenericDatabaseWriter<any>, table: TTable);
   set(values: UpdateSet<TTable>): this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitcn",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "description": "kitcn - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",