@atscript/db 0.1.148 → 0.1.150

package/dist/search-fields-DBIZKwyb.mjs

@@ -0,0 +1,117 @@
+//#region src/shared/derived-rules.ts
+/**
+* The rules the compiler plugin and the runtime share about entities and
+* `@db.column.derived` fields — one dependency-free list each, so a
+* compile-time diagnostic and its runtime mirror can never disagree.
+* @since 0.1.141
+*/
+/** The annotations that make a declaration a DB entity: a table, or a managed / external view. */
+const DB_ENTITY_ANNOTATIONS = [
+	"db.table",
+	"db.view",
+	"db.view.for"
+];
+/** Primitive leaf types a JSON-stored path may end at (view JSON leaves, derived columns). */
+const JSON_LEAF_TYPES = new Set([
+	"string",
+	"number",
+	"boolean"
+]);
+/** Whether `type` (a resolved design type) is one of {@link JSON_LEAF_TYPES}. */
+function isJsonLeafType(type) {
+	return JSON_LEAF_TYPES.has(type);
+}
+/** Annotations a `@db.column.derived` field cannot carry (D8), with the reason. */
+const DERIVED_INCOMPATIBLE = [
+	["meta.id", "a computed column cannot identify the row"],
+	["db.rel.FK", "a foreign key needs a stored, writable column"],
+	["db.default", "the value is computed, never defaulted"],
+	["db.default.increment", "the value is computed, never defaulted"],
+	["db.default.uuid", "the value is computed, never defaulted"],
+	["db.default.now", "the value is computed, never defaulted"],
+	["db.column.version", "the version column is adapter-managed"],
+	["db.column.version.exempt", "a derived column is never written"],
+	["db.encrypted", "the value is a cleartext extraction of its source"],
+	["db.json", "a derived column is a primitive leaf, not a JSON value"],
+	["db.ignore", "an ignored field has no column to derive"],
+	["db.writeOnly", "a derived column is never written"],
+	["db.index.fulltext", "fulltext indexes need a stored text column"],
+	["db.index.geo", "a geo index needs a db.geoPoint column"],
+	["db.search.vector", "a vector index needs a stored embedding column"],
+	["db.mongo.search.text", "Atlas Search indexes the stored document, which holds no derived field"],
+	["db.mongo.search.autocomplete", "Atlas Search indexes the stored document, which holds no derived field"]
+];
+//#endregion
+//#region src/shared/numeric-operand.ts
+/** Primitive tags of timestamps (MySQL may store them as native `TIMESTAMP`). */
+const TIMESTAMP_TAGS = [
+	"timestamp",
+	"created",
+	"updated"
+];
+/**
+* Why a field cannot be an arithmetic operand, or `undefined` when it can: it
+* must be a `number` — not a decimal (exact; an expression is IEEE double) and
+* not a timestamp-tagged number. The one rule behind `@db.compute` (declared,
+* from the `.as` source) and query-time arithmetic (from the runtime
+* descriptor), so the two cannot diverge. Storage rules (`@db.ignore`,
+* encrypted, JSON) stay with the callers.
+*/
+function numericTypeProblem({ base, tags }) {
+	if (base !== "number" && base !== "integer") return base === "decimal" ? "is a decimal" : `is a ${base}`;
+	if (tags && TIMESTAMP_TAGS.some((t) => tags.has(t))) return "is a timestamp";
+}
+//#endregion
+//#region src/shared/search-fields.ts
+/**
+* Problem suffixes, shared by the plugin (compile time) and the runtime
+* metadata build so both word a refusal identically.
+*/
+const SEARCH_PROBLEM = {
+	timestamp: "is a timestamp — filter it by range instead",
+	now: "is a timestamp (@db.default.now) — filter it by range instead",
+	precision: "has @db.column.precision (stored as a decimal)",
+	float: "is a floating-point number — declare it number.int (or a sized integer), add @expect.int, or use @db.default.increment",
+	decimal: "is a decimal"
+};
+/** Problem for a primitive of another base type (`boolean`, …). */
+function otherBaseProblem(base) {
+	return `is a ${base}`;
+}
+/**
+* The one rule behind `@db.column.searchable` / `@db.index.fulltext`:
+* a string (or a non-primitive) is `"text"`; an integer is `"integer"`;
+* floats, decimals, timestamps and other primitives are a `{ problem }`.
+*/
+function searchKindOf(d) {
+	const { base } = d;
+	if (base === void 0 || base === "string") return "text";
+	if (base === "decimal") return { problem: SEARCH_PROBLEM.decimal };
+	if (base !== "number" && base !== "integer") return { problem: otherBaseProblem(base) };
+	if (d.tags && TIMESTAMP_TAGS.some((t) => d.tags.has(t))) return { problem: SEARCH_PROBLEM.timestamp };
+	if (d.now) return { problem: SEARCH_PROBLEM.now };
+	if (d.precision) return { problem: SEARCH_PROBLEM.precision };
+	if (base === "integer" || d.tags?.has("int") || d.expectInt || d.increment) return "integer";
+	return { problem: SEARCH_PROBLEM.float };
+}
+/**
+* Runtime mirror of the plugin's verdict: how the annotated type takes part
+* in `$search`. Structures, arrays, unions and unresolved types keep their
+* legacy `"text"` treatment.
+*/
+function searchMemberKind(type) {
+	const def = type?.type;
+	if (!def || def.kind !== "") return "text";
+	const metadata = type.metadata;
+	const has = (key) => metadata?.has?.(key) === true;
+	return searchKindOf({
+		base: def.designType,
+		tags: def.tags,
+		expectInt: has("expect.int"),
+		increment: has("db.default.increment"),
+		now: has("db.default.now"),
+		precision: has("db.column.precision")
+	});
+}
+//#endregion
+export { DERIVED_INCOMPATIBLE as a, DB_ENTITY_ANNOTATIONS as i, searchMemberKind as n, JSON_LEAF_TYPES as o, numericTypeProblem as r, isJsonLeafType as s, searchKindOf as t };

package/dist/search-fields-DwrsJUC1.cjs

@@ -0,0 +1,158 @@
+//#region src/shared/derived-rules.ts
+/**
+* The rules the compiler plugin and the runtime share about entities and
+* `@db.column.derived` fields — one dependency-free list each, so a
+* compile-time diagnostic and its runtime mirror can never disagree.
+* @since 0.1.141
+*/
+/** The annotations that make a declaration a DB entity: a table, or a managed / external view. */
+const DB_ENTITY_ANNOTATIONS = [
+	"db.table",
+	"db.view",
+	"db.view.for"
+];
+/** Primitive leaf types a JSON-stored path may end at (view JSON leaves, derived columns). */
+const JSON_LEAF_TYPES = new Set([
+	"string",
+	"number",
+	"boolean"
+]);
+/** Whether `type` (a resolved design type) is one of {@link JSON_LEAF_TYPES}. */
+function isJsonLeafType(type) {
+	return JSON_LEAF_TYPES.has(type);
+}
+/** Annotations a `@db.column.derived` field cannot carry (D8), with the reason. */
+const DERIVED_INCOMPATIBLE = [
+	["meta.id", "a computed column cannot identify the row"],
+	["db.rel.FK", "a foreign key needs a stored, writable column"],
+	["db.default", "the value is computed, never defaulted"],
+	["db.default.increment", "the value is computed, never defaulted"],
+	["db.default.uuid", "the value is computed, never defaulted"],
+	["db.default.now", "the value is computed, never defaulted"],
+	["db.column.version", "the version column is adapter-managed"],
+	["db.column.version.exempt", "a derived column is never written"],
+	["db.encrypted", "the value is a cleartext extraction of its source"],
+	["db.json", "a derived column is a primitive leaf, not a JSON value"],
+	["db.ignore", "an ignored field has no column to derive"],
+	["db.writeOnly", "a derived column is never written"],
+	["db.index.fulltext", "fulltext indexes need a stored text column"],
+	["db.index.geo", "a geo index needs a db.geoPoint column"],
+	["db.search.vector", "a vector index needs a stored embedding column"],
+	["db.mongo.search.text", "Atlas Search indexes the stored document, which holds no derived field"],
+	["db.mongo.search.autocomplete", "Atlas Search indexes the stored document, which holds no derived field"]
+];
+//#endregion
+//#region src/shared/numeric-operand.ts
+/** Primitive tags of timestamps (MySQL may store them as native `TIMESTAMP`). */
+const TIMESTAMP_TAGS = [
+	"timestamp",
+	"created",
+	"updated"
+];
+/**
+* Why a field cannot be an arithmetic operand, or `undefined` when it can: it
+* must be a `number` — not a decimal (exact; an expression is IEEE double) and
+* not a timestamp-tagged number. The one rule behind `@db.compute` (declared,
+* from the `.as` source) and query-time arithmetic (from the runtime
+* descriptor), so the two cannot diverge. Storage rules (`@db.ignore`,
+* encrypted, JSON) stay with the callers.
+*/
+function numericTypeProblem({ base, tags }) {
+	if (base !== "number" && base !== "integer") return base === "decimal" ? "is a decimal" : `is a ${base}`;
+	if (tags && TIMESTAMP_TAGS.some((t) => tags.has(t))) return "is a timestamp";
+}
+//#endregion
+//#region src/shared/search-fields.ts
+/**
+* Problem suffixes, shared by the plugin (compile time) and the runtime
+* metadata build so both word a refusal identically.
+*/
+const SEARCH_PROBLEM = {
+	timestamp: "is a timestamp — filter it by range instead",
+	now: "is a timestamp (@db.default.now) — filter it by range instead",
+	precision: "has @db.column.precision (stored as a decimal)",
+	float: "is a floating-point number — declare it number.int (or a sized integer), add @expect.int, or use @db.default.increment",
+	decimal: "is a decimal"
+};
+/** Problem for a primitive of another base type (`boolean`, …). */
+function otherBaseProblem(base) {
+	return `is a ${base}`;
+}
+/**
+* The one rule behind `@db.column.searchable` / `@db.index.fulltext`:
+* a string (or a non-primitive) is `"text"`; an integer is `"integer"`;
+* floats, decimals, timestamps and other primitives are a `{ problem }`.
+*/
+function searchKindOf(d) {
+	const { base } = d;
+	if (base === void 0 || base === "string") return "text";
+	if (base === "decimal") return { problem: SEARCH_PROBLEM.decimal };
+	if (base !== "number" && base !== "integer") return { problem: otherBaseProblem(base) };
+	if (d.tags && TIMESTAMP_TAGS.some((t) => d.tags.has(t))) return { problem: SEARCH_PROBLEM.timestamp };
+	if (d.now) return { problem: SEARCH_PROBLEM.now };
+	if (d.precision) return { problem: SEARCH_PROBLEM.precision };
+	if (base === "integer" || d.tags?.has("int") || d.expectInt || d.increment) return "integer";
+	return { problem: SEARCH_PROBLEM.float };
+}
+/**
+* Runtime mirror of the plugin's verdict: how the annotated type takes part
+* in `$search`. Structures, arrays, unions and unresolved types keep their
+* legacy `"text"` treatment.
+*/
+function searchMemberKind(type) {
+	const def = type?.type;
+	if (!def || def.kind !== "") return "text";
+	const metadata = type.metadata;
+	const has = (key) => metadata?.has?.(key) === true;
+	return searchKindOf({
+		base: def.designType,
+		tags: def.tags,
+		expectInt: has("expect.int"),
+		increment: has("db.default.increment"),
+		now: has("db.default.now"),
+		precision: has("db.column.precision")
+	});
+}
+//#endregion
+Object.defineProperty(exports, "DB_ENTITY_ANNOTATIONS", {
+	enumerable: true,
+	get: function() {
+		return DB_ENTITY_ANNOTATIONS;
+	}
+});
+Object.defineProperty(exports, "DERIVED_INCOMPATIBLE", {
+	enumerable: true,
+	get: function() {
+		return DERIVED_INCOMPATIBLE;
+	}
+});
+Object.defineProperty(exports, "JSON_LEAF_TYPES", {
+	enumerable: true,
+	get: function() {
+		return JSON_LEAF_TYPES;
+	}
+});
+Object.defineProperty(exports, "isJsonLeafType", {
+	enumerable: true,
+	get: function() {
+		return isJsonLeafType;
+	}
+});
+Object.defineProperty(exports, "numericTypeProblem", {
+	enumerable: true,
+	get: function() {
+		return numericTypeProblem;
+	}
+});
+Object.defineProperty(exports, "searchKindOf", {
+	enumerable: true,
+	get: function() {
+		return searchKindOf;
+	}
+});
+Object.defineProperty(exports, "searchMemberKind", {
+	enumerable: true,
+	get: function() {
+		return searchMemberKind;
+	}
+});

package/dist/shared.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_aggregate_rules = require("./aggregate-rules-D_bsCpUI.cjs");
-const require_validation_utils = require("./validation-utils-Da2GjobR.cjs");
+const require_validation_utils = require("./validation-utils-debIYpq0.cjs");
 exports.NOT_DIMENSION_REASON = require_aggregate_rules.NOT_DIMENSION_REASON;
 exports.earlierJoinTargets = require_validation_utils.earlierJoinTargets;
 exports.findFKFieldsPointingTo = require_validation_utils.findFKFieldsPointingTo;
@@ -12,12 +12,14 @@ exports.getNavTargetTypeName = require_validation_utils.getNavTargetTypeName;
 exports.getParentStruct = require_validation_utils.getParentStruct;
 exports.getParentTypeName = require_validation_utils.getParentTypeName;
 exports.hasAnyViewAnnotation = require_validation_utils.hasAnyViewAnnotation;
+exports.integerMemberIndexProblem = require_validation_utils.integerMemberIndexProblem;
 exports.isAliasDecl = require_validation_utils.isAliasDecl;
 exports.isDbSourceDecl = require_validation_utils.isDbSourceDecl;
 exports.isStrictAggregateStruct = require_aggregate_rules.isStrictAggregateStruct;
 exports.joinTargets = require_validation_utils.joinTargets;
 exports.primitiveBaseType = require_validation_utils.primitiveBaseType;
 exports.refActionAnnotation = require_validation_utils.refActionAnnotation;
+exports.searchFieldVerdict = require_validation_utils.searchFieldVerdict;
 exports.validateExclusiveWith = require_validation_utils.validateExclusiveWith;
 exports.validateFieldBaseType = require_validation_utils.validateFieldBaseType;
 exports.validateQueryScope = require_validation_utils.validateQueryScope;

package/dist/shared.d.cts

@@ -8,6 +8,24 @@ declare function validateExclusiveWith(token: Token, selfName: string, others: A
 }>): TMessages;
 /** Primitive base type (`string`, `number`, `decimal`, …) of a resolved definition, if it is a primitive. */
 declare function primitiveBaseType(def: SemanticNode | undefined): string | undefined;
+/**
+ * Whether a prop takes part in `$search` as text or as an integer, or why it
+ * cannot (compile-time mirror of the runtime `searchMemberKind`). Anything
+ * that is not a ref to a primitive (structures, arrays, unions, unresolved
+ * refs) is left alone.
+ */
+declare function searchFieldVerdict(field: SemanticNode, doc: AtscriptDoc): {
+  kind: "string" | "integer" | "other";
+} | {
+  problem: string;
+};
+/**
+ * Why an integer fulltext member is not index-backed (its exact-number match
+ * would scan — or fail on MongoDB next to `$text`), or `undefined`. Backed:
+ * `_id`, the first `@meta.id` of the type, or the first field (in declaration
+ * order) of a `@db.index.plain` / `@db.index.unique` group.
+ */
+declare function integerMemberIndexProblem(token: Token): string | undefined;
 /** Asserts `args[0]` names a sibling property whose primitive base type is `string`. */
 declare function validateSiblingStringField(token: Token, args: Token[], doc: AtscriptDoc, selfName: string): TMessages;
 /**
@@ -139,4 +157,4 @@ declare const NOT_DIMENSION_REASON = "not a dimension";
  */
 declare function isStrictAggregateStruct(struct: SemanticStructureNode): boolean;
 //#endregion
-export { NOT_DIMENSION_REASON, TFKFieldMatch, TRefArgumentOptions, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, isAliasDecl, isDbSourceDecl, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };
+export { NOT_DIMENSION_REASON, TFKFieldMatch, TRefArgumentOptions, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, searchFieldVerdict, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };

package/dist/shared.d.mts

@@ -8,6 +8,24 @@ declare function validateExclusiveWith(token: Token, selfName: string, others: A
 }>): TMessages;
 /** Primitive base type (`string`, `number`, `decimal`, …) of a resolved definition, if it is a primitive. */
 declare function primitiveBaseType(def: SemanticNode | undefined): string | undefined;
+/**
+ * Whether a prop takes part in `$search` as text or as an integer, or why it
+ * cannot (compile-time mirror of the runtime `searchMemberKind`). Anything
+ * that is not a ref to a primitive (structures, arrays, unions, unresolved
+ * refs) is left alone.
+ */
+declare function searchFieldVerdict(field: SemanticNode, doc: AtscriptDoc): {
+  kind: "string" | "integer" | "other";
+} | {
+  problem: string;
+};
+/**
+ * Why an integer fulltext member is not index-backed (its exact-number match
+ * would scan — or fail on MongoDB next to `$text`), or `undefined`. Backed:
+ * `_id`, the first `@meta.id` of the type, or the first field (in declaration
+ * order) of a `@db.index.plain` / `@db.index.unique` group.
+ */
+declare function integerMemberIndexProblem(token: Token): string | undefined;
 /** Asserts `args[0]` names a sibling property whose primitive base type is `string`. */
 declare function validateSiblingStringField(token: Token, args: Token[], doc: AtscriptDoc, selfName: string): TMessages;
 /**
@@ -139,4 +157,4 @@ declare const NOT_DIMENSION_REASON = "not a dimension";
  */
 declare function isStrictAggregateStruct(struct: SemanticStructureNode): boolean;
 //#endregion
-export { NOT_DIMENSION_REASON, TFKFieldMatch, TRefArgumentOptions, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, isAliasDecl, isDbSourceDecl, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };
+export { NOT_DIMENSION_REASON, TFKFieldMatch, TRefArgumentOptions, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, searchFieldVerdict, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };

package/dist/shared.mjs

@@ -1,3 +1,3 @@
 import { n as isStrictAggregateStruct, t as NOT_DIMENSION_REASON } from "./aggregate-rules-jdPrxqWa.mjs";
-import { S as validateSiblingStringField, _ as getParentTypeName, a as hasAnyViewAnnotation, b as validateExclusiveWith, c as joinTargets, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, i as forEachFieldRef, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as primitiveBaseType, x as validateFieldBaseType, y as refActionAnnotation } from "./validation-utils-Dq0uZ7ef.mjs";
-export { NOT_DIMENSION_REASON, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, isAliasDecl, isDbSourceDecl, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };
+import { C as validateFieldBaseType, S as validateExclusiveWith, _ as getParentTypeName, a as hasAnyViewAnnotation, b as refActionAnnotation, c as joinTargets, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, i as forEachFieldRef, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as integerMemberIndexProblem, w as validateSiblingStringField, x as searchFieldVerdict, y as primitiveBaseType } from "./validation-utils-DqZAH6aT.mjs";
+export { NOT_DIMENSION_REASON, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, searchFieldVerdict, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };

package/dist/sync.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_db_error = require("./db-error-DRQH4sLY.cjs");
-const require_column_diff = require("./column-diff-CUU4GvYg.cjs");
+const require_column_diff = require("./column-diff-CKKBVDvx.cjs");
 //#region src/schema/table-option-diff.ts
 /**
 * Computes the difference between desired and existing table options.

package/dist/sync.d.cts

@@ -1,5 +1,5 @@
-import { Dt as TReferencingForeignKey, Et as TPrimaryKeyChange, H as TDbFieldMeta, Mt as TTableOptionDiff, Q as TDbObjectKind, Vn as TGenericLogger, Xt as DbSpace, dt as TDerivedChangeReason, gt as TExistingTableOption, ht as TExistingForeignKey, pt as TEnsureTableOptions } from "./buckets-DJiYlMXc.cjs";
-import { _ as computeTableSnapshot, a as hasForeignKeyChanges, b as snapshotToExistingTableOptions, c as TFieldSnapshot, d as TViewColumnSnapshot, f as TViewJoinSnapshot, g as computeTableHash, h as computeSchemaHash, i as fkKey, l as TForeignKeySnapshot, m as canonicalizeQueryNode, n as computeForeignKeyDiff, o as computeColumnDiff, p as TViewSnapshot, t as TForeignKeyDiff, u as TTableSnapshot, v as computeViewSnapshot, y as snapshotToExistingColumns } from "./fk-diff-BQ4krij8.cjs";
+import { Dt as TPrimaryKeyChange, H as TDbFieldMeta, Hn as TGenericLogger, Nt as TTableOptionDiff, Ot as TReferencingForeignKey, Q as TDbObjectKind, Zt as DbSpace, _t as TExistingTableOption, ft as TDerivedChangeReason, gt as TExistingForeignKey, mt as TEnsureTableOptions } from "./buckets-24Ac4sIS.cjs";
+import { _ as computeTableSnapshot, a as hasForeignKeyChanges, b as snapshotToExistingTableOptions, c as TFieldSnapshot, d as TViewColumnSnapshot, f as TViewJoinSnapshot, g as computeTableHash, h as computeSchemaHash, i as fkKey, l as TForeignKeySnapshot, m as canonicalizeQueryNode, n as computeForeignKeyDiff, o as computeColumnDiff, p as TViewSnapshot, t as TForeignKeyDiff, u as TTableSnapshot, v as computeViewSnapshot, y as snapshotToExistingColumns } from "./fk-diff-CCLiJ9sJ.cjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/schema/sync-entry.d.ts

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
-import { Dt as TReferencingForeignKey, Et as TPrimaryKeyChange, H as TDbFieldMeta, Mt as TTableOptionDiff, Q as TDbObjectKind, Vn as TGenericLogger, Xt as DbSpace, dt as TDerivedChangeReason, gt as TExistingTableOption, ht as TExistingForeignKey, pt as TEnsureTableOptions } from "./buckets-CNdTOnei.mjs";
-import { _ as computeTableSnapshot, a as hasForeignKeyChanges, b as snapshotToExistingTableOptions, c as TFieldSnapshot, d as TViewColumnSnapshot, f as TViewJoinSnapshot, g as computeTableHash, h as computeSchemaHash, i as fkKey, l as TForeignKeySnapshot, m as canonicalizeQueryNode, n as computeForeignKeyDiff, o as computeColumnDiff, p as TViewSnapshot, t as TForeignKeyDiff, u as TTableSnapshot, v as computeViewSnapshot, y as snapshotToExistingColumns } from "./fk-diff-DsaIijVX.mjs";
+import { Dt as TPrimaryKeyChange, H as TDbFieldMeta, Hn as TGenericLogger, Nt as TTableOptionDiff, Ot as TReferencingForeignKey, Q as TDbObjectKind, Zt as DbSpace, _t as TExistingTableOption, ft as TDerivedChangeReason, gt as TExistingForeignKey, mt as TEnsureTableOptions } from "./buckets-XOz0Bw5x.mjs";
+import { _ as computeTableSnapshot, a as hasForeignKeyChanges, b as snapshotToExistingTableOptions, c as TFieldSnapshot, d as TViewColumnSnapshot, f as TViewJoinSnapshot, g as computeTableHash, h as computeSchemaHash, i as fkKey, l as TForeignKeySnapshot, m as canonicalizeQueryNode, n as computeForeignKeyDiff, o as computeColumnDiff, p as TViewSnapshot, t as TForeignKeyDiff, u as TTableSnapshot, v as computeViewSnapshot, y as snapshotToExistingColumns } from "./fk-diff-R8eU7gq-.mjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/schema/sync-entry.d.ts

package/dist/sync.mjs

@@ -1,5 +1,5 @@
 import { r as DbError } from "./db-error-Az85UhTX.mjs";
-import { a as computeTableHash, at as aliasTargetOf, c as snapshotToExistingColumns, d as computeForeignKeyDiff, dt as NoopLogger, f as fkColumns, i as computeSchemaHash, l as snapshotToExistingTableOptions, m as hasForeignKeyChanges, o as computeTableSnapshot, p as fkKey, r as canonicalizeQueryNode, s as computeViewSnapshot, t as computeColumnDiff, u as viewSnapshotSources } from "./column-diff-Cp6ZoyRE.mjs";
+import { _t as NoopLogger, a as computeTableHash, c as snapshotToExistingColumns, d as computeForeignKeyDiff, dt as aliasTargetOf, f as fkColumns, i as computeSchemaHash, l as snapshotToExistingTableOptions, m as hasForeignKeyChanges, o as computeTableSnapshot, p as fkKey, r as canonicalizeQueryNode, s as computeViewSnapshot, t as computeColumnDiff, u as viewSnapshotSources } from "./column-diff-CKLDWBbo.mjs";
 //#region src/schema/table-option-diff.ts
 /**
 * Computes the difference between desired and existing table options.

package/dist/{validation-utils-Dq0uZ7ef.mjs → validation-utils-DqZAH6aT.mjs}

@@ -1,4 +1,4 @@
-import { t as DB_ENTITY_ANNOTATIONS } from "./derived-rules-0sKn4f5C.mjs";
+import { i as DB_ENTITY_ANNOTATIONS, t as searchKindOf } from "./search-fields-DBIZKwyb.mjs";
 import { AnnotationSpec, isArray, isInterface, isPrimitive, isQueryComparison, isQueryLogical, isRef, isStructure } from "@atscript/core";
 //#region src/shared/annotation-utils.ts
 /** Asserts the field carrying this annotation does not also carry any of `others`. */
@@ -24,6 +24,48 @@ function getPrimitiveBaseType(node, doc) {
 	if (!def || !isRef(def)) return void 0;
 	return primitiveBaseType(doc.unwindType(def.id, def.chain)?.def);
 }
+/**
+* Whether a prop takes part in `$search` as text or as an integer, or why it
+* cannot (compile-time mirror of the runtime `searchMemberKind`). Anything
+* that is not a ref to a primitive (structures, arrays, unions, unresolved
+* refs) is left alone.
+*/
+function searchFieldVerdict(field, doc) {
+	const def = field.getDefinition();
+	if (!def || !isRef(def)) return { kind: "other" };
+	const leaf = doc.unwindType(def.id, def.chain)?.def;
+	const base = primitiveBaseType(leaf);
+	if (base === void 0) return { kind: "other" };
+	const kind = searchKindOf({
+		base,
+		tags: isPrimitive(leaf) ? leaf.tags : void 0,
+		expectInt: field.countAnnotations("expect.int") > 0,
+		increment: field.countAnnotations("db.default.increment") > 0,
+		now: field.countAnnotations("db.default.now") > 0,
+		precision: field.countAnnotations("db.column.precision") > 0
+	});
+	if (typeof kind === "object") return kind;
+	return { kind: kind === "integer" ? "integer" : base === "string" ? "string" : "other" };
+}
+/**
+* Why an integer fulltext member is not index-backed (its exact-number match
+* would scan — or fail on MongoDB next to `$text`), or `undefined`. Backed:
+* `_id`, the first `@meta.id` of the type, or the first field (in declaration
+* order) of a `@db.index.plain` / `@db.index.unique` group.
+*/
+function integerMemberIndexProblem(token) {
+	const field = token.parentNode;
+	const struct = getParentStruct(token);
+	if (!struct) return void 0;
+	if (field.id === "_id") return void 0;
+	const props = [...struct.props.values()];
+	if (field.countAnnotations("meta.id") > 0 && props.find((p) => p.countAnnotations("meta.id") > 0) === field) return;
+	for (const ann of ["db.index.plain", "db.index.unique"]) for (const own of field.annotations?.filter((a) => a.name === ann) ?? []) {
+		const group = own.args[0]?.text ?? field.id;
+		if (props.find((p) => p.annotations?.some((a) => a.name === ann && (a.args[0]?.text ?? p.id) === group)) === field) return void 0;
+	}
+	return `@db.index.fulltext on the integer field "${field.id}" needs an index for its exact-number match — make it the primary key (first @meta.id) or the first field of a @db.index.plain / @db.index.unique`;
+}
 /** Asserts `args[0]` names a sibling property whose primitive base type is `string`. */
 function validateSiblingStringField(token, args, doc, selfName) {
 	const errors = [];
@@ -408,4 +450,4 @@ function forEachFieldRef(expr, fn) {
 	}
 }
 //#endregion
-export { validateSiblingStringField as S, getParentTypeName as _, hasAnyViewAnnotation as a, validateExclusiveWith as b, joinTargets as c, viewJoins as d, viewScopeTypes as f, getParentStruct as g, getNavTargetTypeName as h, forEachFieldRef as i, validateQueryScope as l, getDbTableOwner as m, findFKFieldsPointingTo as n, isAliasDecl as o, getAnnotationAlias as p, findViewCycle as r, isDbSourceDecl as s, earlierJoinTargets as t, validateRefArgument as u, primitiveBaseType as v, validateFieldBaseType as x, refActionAnnotation as y };
+export { validateFieldBaseType as C, validateExclusiveWith as S, getParentTypeName as _, hasAnyViewAnnotation as a, refActionAnnotation as b, joinTargets as c, viewJoins as d, viewScopeTypes as f, getParentStruct as g, getNavTargetTypeName as h, forEachFieldRef as i, validateQueryScope as l, getDbTableOwner as m, findFKFieldsPointingTo as n, isAliasDecl as o, getAnnotationAlias as p, findViewCycle as r, isDbSourceDecl as s, earlierJoinTargets as t, validateRefArgument as u, integerMemberIndexProblem as v, validateSiblingStringField as w, searchFieldVerdict as x, primitiveBaseType as y };

package/dist/{validation-utils-Da2GjobR.cjs → validation-utils-debIYpq0.cjs}

@@ -1,4 +1,4 @@
-const require_derived_rules = require("./derived-rules-YstgIxG-.cjs");
+const require_search_fields = require("./search-fields-DwrsJUC1.cjs");
 let _atscript_core = require("@atscript/core");
 //#region src/shared/annotation-utils.ts
 /** Asserts the field carrying this annotation does not also carry any of `others`. */
@@ -24,6 +24,48 @@ function getPrimitiveBaseType(node, doc) {
 	if (!def || !(0, _atscript_core.isRef)(def)) return void 0;
 	return primitiveBaseType(doc.unwindType(def.id, def.chain)?.def);
 }
+/**
+* Whether a prop takes part in `$search` as text or as an integer, or why it
+* cannot (compile-time mirror of the runtime `searchMemberKind`). Anything
+* that is not a ref to a primitive (structures, arrays, unions, unresolved
+* refs) is left alone.
+*/
+function searchFieldVerdict(field, doc) {
+	const def = field.getDefinition();
+	if (!def || !(0, _atscript_core.isRef)(def)) return { kind: "other" };
+	const leaf = doc.unwindType(def.id, def.chain)?.def;
+	const base = primitiveBaseType(leaf);
+	if (base === void 0) return { kind: "other" };
+	const kind = require_search_fields.searchKindOf({
+		base,
+		tags: (0, _atscript_core.isPrimitive)(leaf) ? leaf.tags : void 0,
+		expectInt: field.countAnnotations("expect.int") > 0,
+		increment: field.countAnnotations("db.default.increment") > 0,
+		now: field.countAnnotations("db.default.now") > 0,
+		precision: field.countAnnotations("db.column.precision") > 0
+	});
+	if (typeof kind === "object") return kind;
+	return { kind: kind === "integer" ? "integer" : base === "string" ? "string" : "other" };
+}
+/**
+* Why an integer fulltext member is not index-backed (its exact-number match
+* would scan — or fail on MongoDB next to `$text`), or `undefined`. Backed:
+* `_id`, the first `@meta.id` of the type, or the first field (in declaration
+* order) of a `@db.index.plain` / `@db.index.unique` group.
+*/
+function integerMemberIndexProblem(token) {
+	const field = token.parentNode;
+	const struct = getParentStruct(token);
+	if (!struct) return void 0;
+	if (field.id === "_id") return void 0;
+	const props = [...struct.props.values()];
+	if (field.countAnnotations("meta.id") > 0 && props.find((p) => p.countAnnotations("meta.id") > 0) === field) return;
+	for (const ann of ["db.index.plain", "db.index.unique"]) for (const own of field.annotations?.filter((a) => a.name === ann) ?? []) {
+		const group = own.args[0]?.text ?? field.id;
+		if (props.find((p) => p.annotations?.some((a) => a.name === ann && (a.args[0]?.text ?? p.id) === group)) === field) return void 0;
+	}
+	return `@db.index.fulltext on the integer field "${field.id}" needs an index for its exact-number match — make it the primary key (first @meta.id) or the first field of a @db.index.plain / @db.index.unique`;
+}
 /** Asserts `args[0]` names a sibling property whose primitive base type is `string`. */
 function validateSiblingStringField(token, args, doc, selfName) {
 	const errors = [];
@@ -180,7 +222,7 @@ function refActionAnnotation(name) {
 //#region src/shared/validation-utils.ts
 /** Whether a declaration node is a `@db.table` or a `@db.view` (managed or external). */
 function isDbSourceDecl(node) {
-	return require_derived_rules.DB_ENTITY_ANNOTATIONS.some((name) => node.countAnnotations(name) > 0);
+	return require_search_fields.DB_ENTITY_ANNOTATIONS.some((name) => node.countAnnotations(name) > 0);
 }
 /** Whether a declaration node is a `@db.alias` type. @since 0.1.141 */
 function isAliasDecl(node) {
@@ -468,6 +510,12 @@ Object.defineProperty(exports, "hasAnyViewAnnotation", {
 		return hasAnyViewAnnotation;
 	}
 });
+Object.defineProperty(exports, "integerMemberIndexProblem", {
+	enumerable: true,
+	get: function() {
+		return integerMemberIndexProblem;
+	}
+});
 Object.defineProperty(exports, "isAliasDecl", {
 	enumerable: true,
 	get: function() {
@@ -498,6 +546,12 @@ Object.defineProperty(exports, "refActionAnnotation", {
 		return refActionAnnotation;
 	}
 });
+Object.defineProperty(exports, "searchFieldVerdict", {
+	enumerable: true,
+	get: function() {
+		return searchFieldVerdict;
+	}
+});
 Object.defineProperty(exports, "validateExclusiveWith", {
 	enumerable: true,
 	get: function() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db",
-  "version": "0.1.148",
+  "version": "0.1.150",
   "description": "Database adapter utilities for atscript.",
   "keywords": [
     "atscript",
@@ -71,14 +71,14 @@
     "access": "public"
   },
   "devDependencies": {
-    "@atscript/core": "^0.1.100",
-    "@atscript/typescript": "^0.1.100",
+    "@atscript/core": "^0.1.101",
+    "@atscript/typescript": "^0.1.101",
     "@uniqu/core": "^0.1.13",
-    "unplugin-atscript": "^0.1.100"
+    "unplugin-atscript": "^0.1.101"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.100",
-    "@atscript/typescript": "^0.1.100",
+    "@atscript/core": "^0.1.101",
+    "@atscript/typescript": "^0.1.101",
     "@uniqu/core": "^0.1.13"
   },
   "scripts": {

package/dist/derived-rules-0sKn4f5C.mjs

@@ -1,44 +0,0 @@
-//#region src/shared/derived-rules.ts
-/**
-* The rules the compiler plugin and the runtime share about entities and
-* `@db.column.derived` fields — one dependency-free list each, so a
-* compile-time diagnostic and its runtime mirror can never disagree.
-* @since 0.1.141
-*/
-/** The annotations that make a declaration a DB entity: a table, or a managed / external view. */
-const DB_ENTITY_ANNOTATIONS = [
-	"db.table",
-	"db.view",
-	"db.view.for"
-];
-/** Primitive leaf types a JSON-stored path may end at (view JSON leaves, derived columns). */
-const JSON_LEAF_TYPES = new Set([
-	"string",
-	"number",
-	"boolean"
-]);
-/** Whether `type` (a resolved design type) is one of {@link JSON_LEAF_TYPES}. */
-function isJsonLeafType(type) {
-	return JSON_LEAF_TYPES.has(type);
-}
-/** Annotations a `@db.column.derived` field cannot carry (D8), with the reason. */
-const DERIVED_INCOMPATIBLE = [
-	["meta.id", "a computed column cannot identify the row"],
-	["db.rel.FK", "a foreign key needs a stored, writable column"],
-	["db.default", "the value is computed, never defaulted"],
-	["db.default.increment", "the value is computed, never defaulted"],
-	["db.default.uuid", "the value is computed, never defaulted"],
-	["db.default.now", "the value is computed, never defaulted"],
-	["db.column.version", "the version column is adapter-managed"],
-	["db.encrypted", "the value is a cleartext extraction of its source"],
-	["db.json", "a derived column is a primitive leaf, not a JSON value"],
-	["db.ignore", "an ignored field has no column to derive"],
-	["db.writeOnly", "a derived column is never written"],
-	["db.index.fulltext", "fulltext indexes need a stored text column"],
-	["db.index.geo", "a geo index needs a db.geoPoint column"],
-	["db.search.vector", "a vector index needs a stored embedding column"],
-	["db.mongo.search.text", "Atlas Search indexes the stored document, which holds no derived field"],
-	["db.mongo.search.autocomplete", "Atlas Search indexes the stored document, which holds no derived field"]
-];
-//#endregion
-export { isJsonLeafType as i, DERIVED_INCOMPATIBLE as n, JSON_LEAF_TYPES as r, DB_ENTITY_ANNOTATIONS as t };