@vibeorm/schema 3.0.0 → 4.0.0

package/dist/capabilities.d.ts

@@ -51,6 +51,8 @@ export type DialectCapabilities = {
     readonly exclusionConstraints: boolean;
     readonly exclusionExtensions: readonly string[];
     readonly checkNormalization: "rollback" | "temporary" | "sourceText";
+    /** Typed JSON text, text length and fail-closed boolean expressions in CHECKs. */
+    readonly schemaCheckExpressions: boolean;
     /** Native database row policies; PGlite additionally needs a verified restricted role. */
     readonly nativeRowLevelSecurity: boolean;
     /** INSERT/UPDATE/DELETE ... RETURNING. False ⇒ insertId + re-select fallback. */

package/dist/index.d.ts

@@ -8,9 +8,9 @@ export type { DatabaseModuleOptions, DatabaseModuleManifest, DatabaseModuleArtif
 export { prepareDatabaseModuleSchema } from "./module-schema.ts";
 export type { ExclusionIR, ExclusionSpec, ExclusionKey, ExclusionEndpoint } from "./exclusion.ts";
 export { DIALECTS, ENUM_STORAGES, enumStorageOf, fieldTypeIdentity, isEnumType, providerToDialect } from "./ir.ts";
-export type { CascadeAction, DatasourceIR, DefaultValueIR, Dialect, EnumIR, EnumStorage, ExtensionDeclIR, FieldIR, FieldType, IndexFieldIR, CheckIR, IndexIR, IndexKind, ModelIR, Provider, RelationIR, RelationType, ScalarType, SchemaIR, } from "./ir.ts";
-export { PREDICATE_COMPARISON_OPS, isPredicateFieldRef, predicateFieldNames, predicateKey } from "./predicate.ts";
-export type { PredicateComparisonOp, PredicateFieldRef, PredicateIR, PredicateOperand, PredicateValue } from "./predicate.ts";
+export type { CascadeAction, DatasourceIR, DefaultValueIR, Dialect, EnumIR, EnumStorage, ExtensionDeclIR, FieldIR, FieldType, JsonSchemaRefIR, IndexFieldIR, CheckIR, IndexIR, IndexKind, ModelIR, Provider, RelationIR, RelationType, ScalarType, SchemaIR, } from "./ir.ts";
+export { PREDICATE_COMPARISON_OPS, assertPredicateCapabilities, inspectPredicate, isPredicateFieldRef, predicateFieldNames, predicateKey } from "./predicate.ts";
+export type { PredicateComparisonOp, PredicateExpression, PredicateFieldRef, PredicateIR, PredicateOperand, PredicateValue } from "./predicate.ts";
 export { assertMigrationObjects, isSqlObjectDefinition, isSqlObjectIdentity, sqlObjectKey, sqlObjectNamespace } from "./migration-objects.ts";
 export type { MigrationObjectIR, QualifiedSqlName, SqlObjectDefinition, SqlObjectDefinitionFormat, SqlObjectFacts, SqlObjectIdentity } from "./migration-objects.ts";
 export type { AdvisoryLockMode, DialectCapabilities, FullTextEngine, RowLockStrength, RowLockWaitPolicy, TimeOfDayType, } from "./capabilities.ts";
@@ -35,4 +35,5 @@ export { RLS_CONTEXT_REASONS, RlsContextError } from "./errors.ts";
 export type { RlsContextReason } from "./errors.ts";
 export { isImplicitManyToManyRelation, validateRlsContextIR } from "./validate.ts";
 export { scalarListDefault, serializeJsonDefault } from "./default-values.ts";
+export { assertJsonSchemaRef, hasJsonSchemaAnnotation, jsonSchemaRefIssue, jsonTypeAnnotationIssue, jsonTypeAnnotationRef, normalizeJsonSchemaRef } from "./json-schema-ref.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -260,6 +260,7 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   exclusionConstraints: true,
   exclusionExtensions: Object.freeze(["btree_gist"]),
   checkNormalization: "rollback",
+  schemaCheckExpressions: true,
   nativeRowLevelSecurity: true,
   returning: true,
   scalarArrays: true,
@@ -286,6 +287,7 @@ var SQLITE_CAPABILITIES = Object.freeze({
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "sourceText",
+  schemaCheckExpressions: false,
   nativeRowLevelSecurity: false,
   returning: true,
   scalarArrays: false,
@@ -312,6 +314,7 @@ var MYSQL_CAPABILITIES = Object.freeze({
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "temporary",
+  schemaCheckExpressions: false,
   nativeRowLevelSecurity: false,
   returning: false,
   scalarArrays: false,
@@ -610,36 +613,121 @@ function isPredicateFieldRef(operand) {
   return operand.kind === "field";
 }
 function predicateFieldNames(params) {
-  const seen = new Set;
+  return [...new Set(inspectPredicate(params).expressions.flatMap((expression) => expression.kind === "field" ? [expression.name] : []))];
+}
+function inspectPredicate(params) {
+  const expressions = [];
+  let checkOnly = false;
+  const expression = (node) => {
+    if (typeof node !== "object" || node === null)
+      throw invalidOperand();
+    switch (node.kind) {
+      case "field":
+        expressions.push(node);
+        return;
+      case "jsonText":
+        if (typeof node.field !== "object" || node.field === null || node.field.kind !== "field")
+          throw invalidOperand();
+        expressions.push(node);
+        checkOnly = true;
+        expression(node.field);
+        return;
+      case "length":
+        expressions.push(node);
+        checkOnly = true;
+        expression(node.expression);
+        return;
+      default:
+        throw invalidOperand();
+    }
+  };
   const walk = (node) => {
     switch (node.kind) {
       case "compare":
-        seen.add(node.left.name);
-        if (isPredicateFieldRef(node.right))
-          seen.add(node.right.name);
+        expression(node.left);
+        if (typeof node.right !== "object" || node.right === null || node.right.kind !== "value")
+          expression(node.right);
         return;
       case "inList":
       case "isNull":
-        seen.add(node.field.name);
+        expression(node.field);
         return;
       case "and":
       case "or":
         for (const operand of node.operands)
           walk(operand);
         return;
+      case "isTrue":
+        checkOnly = true;
+        walk(node.operand);
+        return;
       case "not":
         walk(node.operand);
         return;
     }
   };
   walk(params.predicate);
-  return [...seen];
+  return { expressions, checkOnly };
+}
+function invalidOperand() {
+  return new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: "A schema predicate operand must be a field, jsonText or length expression, or a literal on the right of a comparison",
+    meta: { rule: "predicate-operand-invalid" }
+  });
+}
+function assertPredicateCapabilities(params) {
+  if (!inspectPredicate(params).checkOnly)
+    return;
+  if (params.usage !== "check")
+    throw unsupportedCapability({ dialect: params.dialect, feature: "schema CHECK expressions outside CHECK constraints" });
+  if (!DIALECT_CAPABILITIES[params.dialect].schemaCheckExpressions)
+    throw unsupportedCapability({ dialect: params.dialect, feature: "schemaCheckExpressions" });
 }
 function predicateKey(params) {
+  if (inspectPredicate(params).checkOnly) {
+    const scalar = (node) => {
+      switch (node.kind) {
+        case "field":
+          return ["field", node.name];
+        case "jsonText":
+          return ["jsonText", node.field.name, node.path];
+        case "length":
+          return ["length", scalar(node.expression)];
+      }
+    };
+    const key = (node) => {
+      switch (node.kind) {
+        case "compare":
+          return [node.kind, node.op, scalar(node.left), node.right.kind === "value" ? ["value", node.right.value] : scalar(node.right)];
+        case "inList":
+          return [node.kind, node.field.name, node.negate === true, node.values.map((value) => value.value)];
+        case "isNull":
+          return [node.kind, node.field.name, node.negate === true];
+        case "and":
+        case "or":
+          return [node.kind, node.operands.map(key)];
+        case "not":
+        case "isTrue":
+          return [node.kind, key(node.operand)];
+      }
+    };
+    return `check:${JSON.stringify(key(params.predicate))}`;
+  }
+  const expression = (node) => {
+    switch (node.kind) {
+      case "field":
+        return `f:${node.name}`;
+      case "jsonText":
+        return `jsonText(${JSON.stringify([node.field.name, node.path])})`;
+      case "length":
+        return `length(${expression(node.expression)})`;
+    }
+  };
   const encode = (node) => {
     switch (node.kind) {
       case "compare":
-        return `cmp(${node.op},${node.left.name},${isPredicateFieldRef(node.right) ? `f:${node.right.name}` : `v:${typeof node.right.value}:${String(node.right.value)}`})`;
+        return `cmp(${node.op},${node.left.kind === "field" ? node.left.name : expression(node.left)},${node.right.kind === "value" ? `v:${typeof node.right.value}:${String(node.right.value)}` : expression(node.right)})`;
       case "inList":
         return `in${node.negate === true ? "!" : ""}(${node.field.name},[${node.values.map((entry) => `${typeof entry.value}:${String(entry.value)}`).join("|")}])`;
       case "isNull":
@@ -649,6 +737,8 @@ function predicateKey(params) {
         return `${node.kind}(${node.operands.map(encode).join(",")})`;
       case "not":
         return `not(${encode(node.operand)})`;
+      case "isTrue":
+        return `isTrue(${encode(node.operand)})`;
     }
   };
   return encode(params.predicate);
@@ -803,6 +893,7 @@ var RESERVED_CLIENT_NAMES = [
   "$disconnect",
   "$transaction",
   "$querySql",
+  "$querySqlResult",
   "$executeSql",
   "$queryRaw",
   "$queryRawUnsafe",
@@ -1097,6 +1188,80 @@ function scalarListDefault(params) {
   });
 }
 
+// packages/schema/src/json-schema-ref.ts
+var EXPORT_NAME = /^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u;
+var REFERENCE_ANNOTATION = /@(schema|type)\(\s*([$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*)\s+from\s+("(?:[^"\\\r\n]|\\.)*")\s*\)/gu;
+function annotations(params) {
+  const matches = [...params.documentation.matchAll(REFERENCE_ANNOTATION)].filter((match) => match[1] === params.kind);
+  const remaining = params.documentation.replace(REFERENCE_ANNOTATION, "");
+  const malformed = remaining.match(params.kind === "schema" ? /@schema(?=\s*\(|\s|$)/gu : /@type(?=\s*\(|\s|$)/gu) ?? [];
+  return { matches, count: matches.length + malformed.length };
+}
+function hasJsonSchemaAnnotation(params) {
+  return annotations({ documentation: params.documentation ?? "", kind: "schema" }).count > 0;
+}
+function jsonTypeAnnotationIssue(params) {
+  const refs = annotations({ documentation: params.documentation ?? "", kind: "type" });
+  if (refs.count === 0)
+    return;
+  if (refs.count > 1)
+    return "A field may declare only one assertion-only JSON type";
+  const match = refs.matches[0];
+  if (match === undefined)
+    return 'Expected @type(Name from "specifier")';
+  return jsonSchemaRefIssue({ value: { name: match[2], from: decodePrismaString({ raw: match[3] }) } });
+}
+function jsonTypeAnnotationRef(params) {
+  const issue = jsonTypeAnnotationIssue(params);
+  if (issue !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { issues: [{ rule: "invalid-json-type-ref", message: issue }] } });
+  const match = annotations({ documentation: params.documentation ?? "", kind: "type" }).matches[0];
+  return match === undefined ? undefined : assertJsonSchemaRef({ value: { name: match[2], from: decodePrismaString({ raw: match[3] }) } });
+}
+function jsonSchemaRefIssue(params) {
+  const { value } = params;
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return "JSON schema reference must be { name, from }; validators belong in the referenced export";
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== 2 || !keys.includes("name") || !keys.includes("from"))
+    return "JSON schema reference accepts only name and from";
+  const name = Object.getOwnPropertyDescriptor(value, "name");
+  const from = Object.getOwnPropertyDescriptor(value, "from");
+  if (name?.enumerable !== true || !("value" in name) || typeof name.value !== "string" || !EXPORT_NAME.test(name.value) || name.value === "default")
+    return "JSON schema name must be a valid named export, not default";
+  if (from?.enumerable !== true || !("value" in from) || typeof from.value !== "string" || from.value.trim().length === 0 || /[\u0000-\u001f\u007f]/u.test(from.value))
+    return "JSON schema from must be a non-empty import specifier without control characters";
+  return;
+}
+function assertJsonSchemaRef(params) {
+  const issue = jsonSchemaRefIssue(params);
+  if (issue !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { issues: [{ rule: "invalid-json-schema-ref", message: issue }] } });
+  const value = params.value;
+  return Object.freeze({ name: value.name, from: value.from });
+}
+function normalizeJsonSchemaRef(params) {
+  const { documentation, reference } = params;
+  const jsonType = jsonTypeAnnotationRef({ documentation });
+  const refs = annotations({ documentation: documentation ?? "", kind: "schema" });
+  let jsonSchema = reference === undefined ? undefined : assertJsonSchemaRef({ value: reference });
+  let remaining = documentation;
+  if (refs.count > 1 || refs.count > 0 && jsonSchema !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field may declare only one JSON schema reference", meta: { issues: [{ rule: "duplicate-json-schema-ref" }] } });
+  if (refs.count === 1) {
+    const match = refs.matches[0];
+    if (match === undefined)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: 'Expected @schema(Name from "specifier")', meta: { issues: [{ rule: "invalid-json-schema-ref" }] } });
+    jsonSchema = assertJsonSchemaRef({ value: { name: match[2], from: decodePrismaString({ raw: match[3] }) } });
+    remaining = documentation?.replace(match[0], "").trim();
+    if (remaining === "")
+      remaining = undefined;
+  }
+  if (jsonSchema !== undefined && jsonType !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "JSON schema validation and assertion-only @type cannot be combined on one field", meta: { issues: [{ rule: "conflicting-json-schema-ref" }] } });
+  return { ...remaining === undefined ? {} : { documentation: remaining }, ...jsonSchema === undefined ? {} : { jsonSchema } };
+}
+
 // packages/schema/src/m2m.ts
 function implicitJoinTable(params) {
   const sorted = [params.modelA, params.modelB].sort();
@@ -1122,6 +1287,8 @@ var RESERVED_ENUM_NAMES = [
   "SqlColumn",
   "SqlFragment",
   "ResultDecoder",
+  "ResultReadDecoder",
+  "SqlQueryResult",
   "ExtendedDateTime",
   "enumValidators",
   "enumValidator",
@@ -1178,6 +1345,9 @@ var RESERVED_ENUM_NAMES = [
   "InputJsonValue",
   "InputJsonArray",
   "InputJsonObject",
+  "BoundJsonFilter",
+  "BoundJsonFilterCommon",
+  "BoundJsonNullableFilter",
   "VibeTelemetryOptions",
   "VibeTelemetryExporter",
   "VibeTelemetryOperationEvent",
@@ -1874,6 +2044,23 @@ function validateModel(params) {
       });
     }
     memberNames.add(field.name);
+    const typedIssue = jsonTypeAnnotationIssue({ documentation: field.documentation });
+    if (typedIssue !== undefined)
+      issues.push({ rule: "invalid-json-type-ref", message: typedIssue, model: model.name, field: field.name });
+    const hasType = typedIssue === undefined && jsonTypeAnnotationRef({ documentation: field.documentation }) !== undefined;
+    if (hasType && field.type !== "Json")
+      issues.push({ rule: "json-type-non-json", message: "JSON type assertions are only valid on Json fields", model: model.name, field: field.name });
+    if (field.jsonSchema !== undefined) {
+      const issue = jsonSchemaRefIssue({ value: field.jsonSchema });
+      if (issue !== undefined)
+        issues.push({ rule: "invalid-json-schema-ref", message: issue, model: model.name, field: field.name });
+      if (field.type !== "Json" || field.isUnsupported === true)
+        issues.push({ rule: "json-schema-non-json", message: "JSON schemas are only valid on queryable Json fields", model: model.name, field: field.name });
+      if (hasType)
+        issues.push({ rule: "conflicting-json-schema-ref", message: "A field cannot declare both @type and a JSON schema", model: model.name, field: field.name });
+    }
+    if (hasJsonSchemaAnnotation({ documentation: field.documentation }))
+      issues.push({ rule: "unnormalized-json-schema-ref", message: "Normalize @schema documentation into FieldIR.jsonSchema before consuming SchemaIR", model: model.name, field: field.name });
     const typeIdentity = field.nativeTypeIdentity;
     if (typeIdentity !== undefined && (typeIdentity === null || typeof typeIdentity !== "object" || field.isUnsupported !== true || typeof typeIdentity.source !== "string" || typeIdentity.source !== field.nativeType || typeof typeIdentity.namespace !== "string" || typeIdentity.namespace.length === 0 || typeIdentity.namespace.includes("\x00"))) {
       issues.push({ rule: "invalid-native-type-identity", message: `PostgreSQL type identity on "${model.name}.${field.name}" must be bound to its unsupported declaration`, model: model.name, field: field.name });
@@ -2117,6 +2304,8 @@ function validateModel(params) {
         model,
         fieldNames,
         site: `CHECK "${check.name}"`,
+        usage: "check",
+        dialect: providerToDialect({ provider: params.schema.datasource.provider }),
         issues
       });
     }
@@ -2138,13 +2327,55 @@ function validateModel(params) {
         model,
         fieldNames,
         site: `partial index on [${index.fields.map((entry) => entry.name).join(", ")}]`,
+        usage: "indexPredicate",
+        dialect: providerToDialect({ provider: params.schema.datasource.provider }),
         issues
       });
     }
   }
+  for (const exclusion of model.exclusions ?? []) {
+    const predicate = exclusion.source?.where;
+    if (predicate !== undefined)
+      validatePredicateFields({ predicate, model, fieldNames, site: `exclusion "${exclusion.name}"`, usage: "exclusionPredicate", dialect: providerToDialect({ provider: params.schema.datasource.provider }), issues });
+  }
 }
 function validatePredicateFields(params) {
   const { predicate, model, fieldNames, site, issues } = params;
+  const inspection = inspectPredicate({ predicate });
+  if (inspection.checkOnly && (params.usage !== "check" || !DIALECT_CAPABILITIES[params.dialect].schemaCheckExpressions)) {
+    issues.push({ rule: "predicate-check-capability", message: `${site}: computed schema predicates require a PostgreSQL CHECK`, model: model.name });
+  }
+  const expressionType = (expression) => {
+    if (expression.kind === "field")
+      return model.fields.find((field) => field.name === expression.name)?.type;
+    if (expression.kind === "jsonText") {
+      const field = model.fields.find((candidate) => candidate.name === expression.field.name);
+      if (field !== undefined && (field.type !== "Json" || field.isUnsupported === true))
+        issues.push({ rule: "predicate-type-mismatch", message: `${site}: jsonText requires a Json field`, model: model.name, field: field.name });
+      if (!Array.isArray(expression.path) || Array.from(expression.path).some((segment) => typeof segment !== "string" || segment.includes("\x00")))
+        issues.push({ rule: "predicate-json-path", message: `${site}: jsonText requires a string-only path without NUL bytes`, model: model.name });
+      return "String";
+    }
+    if (expressionType(expression.expression) !== "String")
+      issues.push({ rule: "predicate-type-mismatch", message: `${site}: length requires a text expression`, model: model.name });
+    return "Int";
+  };
+  const validateComputedComparisons = (node) => {
+    if (node.kind === "compare") {
+      if (node.left.kind !== "field" || node.right.kind !== "value" && node.right.kind !== "field") {
+        const left = expressionType(node.left);
+        const right = node.right.kind === "value" ? undefined : expressionType(node.right);
+        if (left !== undefined && right !== undefined && left !== right)
+          issues.push({ rule: "predicate-type-mismatch", message: `${site}: computed comparison operands must have the same scalar type`, model: model.name });
+        if (node.right.kind === "value" && left === "String" && typeof node.right.value !== "string")
+          issues.push({ rule: "predicate-type-mismatch", message: `${site}: a text expression requires a string literal`, model: model.name });
+      }
+    } else if (node.kind === "and" || node.kind === "or")
+      node.operands.forEach(validateComputedComparisons);
+    else if (node.kind === "not" || node.kind === "isTrue")
+      validateComputedComparisons(node.operand);
+  };
+  validateComputedComparisons(predicate);
   for (const name of predicateFieldNames({ predicate })) {
     if (!fieldNames.has(name)) {
       issues.push({
@@ -2155,7 +2386,10 @@ function validatePredicateFields(params) {
       });
       continue;
     }
-    if (model.fields.find((field) => field.name === name)?.isList === true) {
+    const referenced = model.fields.find((field) => field.name === name);
+    if (inspection.checkOnly && referenced?.isUnsupported === true)
+      issues.push({ rule: "predicate-unsupported-type", message: `${site}: computed predicates cannot reference unsupported fields`, model: model.name, field: name });
+    if (referenced?.isList === true) {
       issues.push({
         rule: "predicate-list-field",
         message: `${site} on "${model.name}" compares scalar list "${name}" \u2014 use a raw expression for array operators`,
@@ -2182,6 +2416,12 @@ function assertValidSchemaIR(params) {
         throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Enum reference namespace differs from its declared native type", meta: { rule: "enum-namespace", model: model.name, field: field.name } });
     }
   for (const model of params.schema.models) {
+    for (const check of model.checks ?? [])
+      if (check.predicate !== undefined)
+        assertPredicateCapabilities({ predicate: check.predicate, dialect, usage: "check" });
+    for (const index of model.indexes)
+      if (index.wherePredicate !== undefined)
+        assertPredicateCapabilities({ predicate: index.wherePredicate, dialect, usage: "indexPredicate" });
     if (model.exclusions !== undefined && !Array.isArray(model.exclusions))
       throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusions must be an array", meta: { rule: "exclusion-definition" } });
     if ((model.exclusions?.length ?? 0) === 0)
@@ -2195,6 +2435,8 @@ function assertValidSchemaIR(params) {
         throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid exclusion declaration", meta: { rule: "exclusion-definition" } });
       const source = exclusion.source;
       if (source !== undefined) {
+        if (source.where !== undefined)
+          assertPredicateCapabilities({ predicate: source.where, dialect, usage: "exclusionPredicate" });
         const references = [...source.keys.flatMap((key) => ("field" in key) ? [key.field] : key.fields), ...[source.range.lower, source.range.upper].flatMap((endpoint) => ("field" in endpoint) ? [endpoint.field] : []), ...source.where === undefined ? [] : predicateFieldNames({ predicate: source.where })];
         if (references.some((name) => !model.fields.some((field) => field.name === name && !field.isList)))
           throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusion references an unknown or list field", meta: { rule: "exclusion-field", model: model.name } });
@@ -2456,7 +2698,9 @@ export {
   VibeError,
   assertIdentifierFits,
   assertIndexOperatorClasses,
+  assertJsonSchemaRef,
   assertMigrationObjects,
+  assertPredicateCapabilities,
   assertSqlNamespace,
   assertValidSchemaIR,
   buildComputedManifest,
@@ -2475,9 +2719,11 @@ export {
   extensionOptionsHash,
   fieldTypeIdentity,
   fitDefaultName,
+  hasJsonSchemaAnnotation,
   identifierLength,
   implicitJoinTable,
   implicitJoinTableObjectNames,
+  inspectPredicate,
   internalError,
   invalidStoredData,
   isEnumType,
@@ -2487,7 +2733,11 @@ export {
   isReservedDelegateName,
   isSqlObjectDefinition,
   isSqlObjectIdentity,
+  jsonSchemaRefIssue,
+  jsonTypeAnnotationIssue,
+  jsonTypeAnnotationRef,
   mergeExtensionDeclarations,
+  normalizeJsonSchemaRef,
   postgresGeneratedObjectName,
   predicateFieldNames,
   predicateKey,
@@ -2506,4 +2756,4 @@ export {
   validateSchemaIR
 };
 
-//# debugId=99BBBD6C3E58D9DD64756E2164756E21
+//# debugId=6D288D6F1DD93E5864756E2164756E21