@sequenceholdings/orm 2.4.0 → 2.6.0

package/dist/compiler.js

@@ -6,12 +6,17 @@ import { PgParser } from '@supabase/pg-parser';
 // src/compiler-gql/artifact.ts
 
 // src/constants.ts
+var NAMESPACE_PATTERN = /^(?!(?:events|native_sources)$)[a-z][a-z0-9_]{0,40}$/;
 var COLUMN_IDENTIFIER_PATTERN = /^_?[a-z][a-z0-9_]*$/;
 var MAX_IDENTIFIER_LENGTH = 63;
 var CAPABILITY_KEY_PATTERN = /^(?:org\/|app\/[a-z][a-z0-9-]{0,63}\/)?[a-z0-9-]{1,64}$/;
+var MAX_PERSISTED_READ_ROWS = 50001;
 var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]{0,62}\.[a-z][a-z0-9_]{0,62}$/;
 var ORM_SCHEMA_PREFIX = "orm_";
-var ormSchemaName = (namespace) => `${ORM_SCHEMA_PREFIX}${namespace}`;
+var ormSchemaName = (namespace) => {
+  if (!NAMESPACE_PATTERN.test(namespace)) throw new Error(`invalid or reserved ORM namespace '${namespace}'`);
+  return `${ORM_SCHEMA_PREFIX}${namespace}`;
+};
 var CELL_PARTS = ["at", "by", "rev", "source", "conflicts"];
 var CELL_PART_SUFFIX = {
   at: "__at",
@@ -387,6 +392,7 @@ function validateResolvedView({ view, tables, views = [] }) {
 function validateSource({ scope, source, table }) {
   const { fail: fail4 } = scope;
   if (source.kind === "etl" && table.source === void 0) fail4(`etl source '${source.name}' must reference a synced table`);
+  if (source.kind === "etl" && table.primaryKey?.length === 0) fail4(`etl source '${source.name}' cannot use an unkeyed synced table for resolved row identity`);
   if (source.kind !== "etl" && (table.internal !== true || table.cellMetadata !== true)) {
     fail4(`${source.kind} source '${source.name}' must reference an internal table with cell metadata`);
   }
@@ -618,6 +624,163 @@ function isSingleViewQuerySql(value) {
   }
   return state === "normal" && !/\$[a-z_0-9]*\$/i.test(query);
 }
+var VIEW_QUERY_FUNCTION_ALLOWLIST = [
+  "abs",
+  "age",
+  "array_agg",
+  "array_append",
+  "array_cat",
+  "array_dims",
+  "array_length",
+  "array_lower",
+  "array_ndims",
+  "array_position",
+  "array_positions",
+  "array_prepend",
+  "array_remove",
+  "array_replace",
+  "array_to_string",
+  "array_trim",
+  "array_upper",
+  "ascii",
+  "avg",
+  "bit_and",
+  "bit_or",
+  "bit_xor",
+  "bool_and",
+  "bool_or",
+  "btrim",
+  "cardinality",
+  "cbrt",
+  "ceil",
+  "ceiling",
+  "char_length",
+  "character_length",
+  "chr",
+  "concat",
+  "concat_ws",
+  "count",
+  "cume_dist",
+  "date_bin",
+  "date_part",
+  "date_trunc",
+  "decode",
+  "degrees",
+  "dense_rank",
+  "encode",
+  "enum_first",
+  "enum_last",
+  "enum_range",
+  "every",
+  "exp",
+  "first_value",
+  "floor",
+  "format",
+  "grouping",
+  "initcap",
+  "json_agg",
+  "json_array_length",
+  "json_build_array",
+  "json_build_object",
+  "json_extract_path",
+  "json_extract_path_text",
+  "json_object_agg",
+  "json_object_keys",
+  "json_strip_nulls",
+  "json_typeof",
+  "jsonb_agg",
+  "jsonb_array_length",
+  "jsonb_build_array",
+  "jsonb_build_object",
+  "jsonb_extract_path",
+  "jsonb_extract_path_text",
+  "jsonb_insert",
+  "jsonb_object_agg",
+  "jsonb_object_keys",
+  "jsonb_path_exists",
+  "jsonb_path_match",
+  "jsonb_path_query",
+  "jsonb_path_query_array",
+  "jsonb_path_query_first",
+  "jsonb_pretty",
+  "jsonb_set",
+  "jsonb_set_lax",
+  "jsonb_strip_nulls",
+  "jsonb_typeof",
+  "justify_days",
+  "justify_hours",
+  "justify_interval",
+  "lag",
+  "last_value",
+  "lead",
+  "left",
+  "length",
+  "ln",
+  "log",
+  "lower",
+  "lpad",
+  "ltrim",
+  "make_date",
+  "make_interval",
+  "make_time",
+  "make_timestamp",
+  "make_timestamptz",
+  "max",
+  "md5",
+  "min",
+  "mod",
+  "nth_value",
+  "ntile",
+  "octet_length",
+  "percent_rank",
+  "pi",
+  "power",
+  "quote_ident",
+  "quote_literal",
+  "quote_nullable",
+  "radians",
+  "rank",
+  "regexp_count",
+  "regexp_instr",
+  "regexp_like",
+  "regexp_match",
+  "regexp_matches",
+  "regexp_replace",
+  "regexp_split_to_array",
+  "regexp_split_to_table",
+  "repeat",
+  "replace",
+  "reverse",
+  "right",
+  "round",
+  "row_number",
+  "rpad",
+  "rtrim",
+  "sign",
+  "split_part",
+  "sqrt",
+  "starts_with",
+  "string_agg",
+  "string_to_array",
+  "strpos",
+  "substr",
+  "substring",
+  "sum",
+  "timezone",
+  "to_ascii",
+  "to_char",
+  "to_date",
+  "to_hex",
+  "to_json",
+  "to_jsonb",
+  "to_number",
+  "to_timestamp",
+  "translate",
+  "trunc",
+  "unnest",
+  "upper",
+  "width_bucket"
+];
 var canonicalActionSchema = z.object({
   name: identifier2,
   requires: z.string().max(1e3).optional(),
@@ -678,7 +841,7 @@ var canonicalTableSchema = z.object({
   /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
   source: z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: z.array(canonicalColumnSchema).default([]),
-  primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
+  primaryKey: z.array(columnIdentifier).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
   indexes: z.array(canonicalIndexSchema).default([]),
   /** Omitted by old definitions, preserving their existing content hashes. */
@@ -714,6 +877,29 @@ var canonicalTableSchema = z.object({
    * data plane. Omitted otherwise.
    */
   materializes: identifier2.optional()
+}).superRefine((table, ctx) => {
+  if (table.primaryKey?.length !== 0) return;
+  const fail4 = (message, path = ["primaryKey"]) => ctx.addIssue({ code: "custom", path, message: `unkeyed table '${table.table}' ${message}` });
+  if (table.source === void 0 || table.columns.length === 0) {
+    fail4("requires a typed synced source");
+  }
+  if ([table.policies.write, table.policies.insert, table.policies.update].some((policy) => policy !== void 0)) {
+    fail4("is read-only and cannot declare write policies", ["policies"]);
+  }
+  const ownedCollections = [table.indexes, table.actions, table.checks, table.foreignKeys, table.cowMutations];
+  const ownedMetadata = [table.cellMetadata, table.internal, table.materializes, table.renamedFrom];
+  if (ownedCollections.some((items) => items !== void 0 && items.length > 0) || ownedMetadata.some((value) => value !== void 0)) {
+    fail4("cannot declare owned storage, constraints or identity operations");
+  }
+  for (const [index, column] of table.columns.entries()) {
+    const ownedColumnMetadata = [column.default, column.defaultFn, column.onUpdateFn, column.renamedFrom, column.cast, column.cell];
+    if (column.unique || ownedColumnMetadata.some((value) => value !== void 0)) {
+      fail4("cannot declare column uniqueness, mutation defaults or migration metadata", ["columns", index]);
+    }
+  }
+  for (const [index, link] of table.links.entries()) {
+    if (link.enforce || link.kind === "toMany") fail4("cannot provide an identity for this link", ["links", index]);
+  }
 });
 var MAX_VIEW_QUERY = 1e5;
 var MAX_RESOLVED_VIEW_QUERY = 5e6;
@@ -770,6 +956,26 @@ var canonicalViewSchema = z.object({
     }
   }
 });
+function validateUnkeyedLinkIdentities({ definition, ctx }) {
+  const tables = new Map(definition.tables.map((table) => [table.table, table]));
+  const relations = [
+    ...definition.tables.map((table, index) => ({ kind: "tables", index, links: table.links })),
+    ...(definition.views ?? []).map((view, index) => ({ kind: "views", index, links: view.links }))
+  ];
+  for (const relation of relations) {
+    for (const [linkIndex, link] of relation.links.entries()) {
+      if (link.kind !== "toOne" || link.namespace !== void 0 && link.namespace !== definition.namespace) continue;
+      const target = link.target === void 0 ? void 0 : tables.get(link.target);
+      if (target?.source !== void 0 && target.primaryKey?.length === 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: [relation.kind, relation.index, "links", linkIndex],
+          message: `link '${link.name}' cannot use unkeyed table '${target.table}' as a to-one identity`
+        });
+      }
+    }
+  }
+}
 var CELL_PART_TYPES = {
   at: "timestamptz",
   by: "text",
@@ -833,7 +1039,7 @@ var exportGateSchema = z.union([z.literal(true), z.object({ capability: z.string
 var relationExportSchema = z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
 var localDefinitionSchema = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
-  namespace: identifier2.max(41),
+  namespace: identifier2.max(41).regex(NAMESPACE_PATTERN, "invalid or reserved ORM namespace"),
   description: z.string().max(2e3).optional(),
   enums: z.array(canonicalEnumSchema).default([]),
   tables: z.array(canonicalTableSchema).min(0).max(500),
@@ -867,6 +1073,7 @@ var localDefinitionSchema = z.object({
     }
   }
   const fkTables = new Map(definition.tables.map((table) => [table.table, table]));
+  validateUnkeyedLinkIdentities({ definition, ctx });
   const relations = /* @__PURE__ */ new Set([...fkTables.keys(), ...(definition.views ?? []).map((view) => view.view)]);
   for (const name2 of Object.keys(definition.exports ?? {})) {
     if (!relations.has(name2)) ctx.addIssue({ code: "custom", path: ["exports", name2], message: `export '${name2}' is not a local object` });
@@ -1101,6 +1308,9 @@ function normalizeCanonical(definition) {
   return normalized;
 }
 
+// src/client/sql.ts
+var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
+
 // src/ir/index.ts
 var IR_VERSION = 5;
 var LEGACY_IR_VERSION = 1;
@@ -1189,7 +1399,7 @@ var limitIrSchema = z.object({
   variable: z.string().optional(),
   value: z.number().int().positive().optional(),
   default: z.number().int().positive(),
-  max: z.number().int().positive()
+  max: z.number().int().positive().max(MAX_PERSISTED_READ_ROWS)
 });
 var selectionIrSchema = z.lazy(
   () => z.object({
@@ -1434,7 +1644,8 @@ var compiledOperationSchema = z.object({
 }).superRefine((operation, ctx) => {
   if (operation.language === "sql") {
     const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
-    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !operation.requires?.capability) {
+    const builtin = operation.name === "BuiltinSqlRead" && operation.opHash === BUILTIN_SQL_READ_HASH && operation.requires === null;
+    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !builtin && !operation.requires?.capability) {
       ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
     }
   } else if (operation.sql || operation.sqlQuery || operation.roots.length === 0) {
@@ -2826,6 +3037,7 @@ function buildCompileContext(rawCanonical) {
   const platformMeta = usesPlatformUsers ? platformUserMeta() : void 0;
   if (platformMeta) tables[PLATFORM_USER_TABLE] = platformMeta;
   const syncedTableNames = new Set(canonical.tables.filter((t) => t.source !== void 0).map((t) => t.table));
+  const unkeyedSyncedTableNames = new Set(relations.filter((table) => table.source !== void 0 && table.primaryKey?.length === 0).map((table) => table.table));
   const viewDependencies = new Map((canonical.views ?? []).map((view) => [view.view, view.dependencies]));
   const claimsGatedMemo = /* @__PURE__ */ new Map();
   const relationIsClaimsGated = (name2) => {
@@ -2839,6 +3051,7 @@ function buildCompileContext(rawCanonical) {
   };
   for (const table of relations) {
     const isView = viewNames.has(table.table);
+    const readOnly = isView || unkeyedSyncedTableNames.has(table.table);
     const owner = owners.get(table.table);
     const entries = resolveColumnEntries(table, enums, diagnostics);
     columnEntries.set(table.table, entries);
@@ -2886,13 +3099,13 @@ function buildCompileContext(rawCanonical) {
       // are claims-gated — see tableMetaIrSchema.claimsGated.
       claimsGated: relationIsClaimsGated(table.table),
       columns: entries.map(({ deprecated: _deprecated, onUpdateFn: _onUpdateFn, ...column }) => column),
-      primaryKey: isView ? primaryKey : primaryKey.length > 0 ? primaryKey : ["id"],
+      primaryKey: isView || unkeyedSyncedTableNames.has(table.table) ? primaryKey : primaryKey.length > 0 ? primaryKey : ["id"],
       links: [],
       filterable: data.map((c) => c.name),
       orderable: data.filter((c) => c.type !== "jsonb").map((c) => c.name),
-      insertable: resolved ? resolvedWritable(data) : isView ? [] : active.map((c) => c.name),
-      settable: resolved ? resolvedWritable(data).filter((name2) => !primaryKey.includes(name2)) : isView ? [] : active.filter((c) => !c.onUpdateFn).map((c) => c.name),
-      appendable: isView ? [] : active.filter((c) => c.type === "jsonb").map((c) => c.name),
+      insertable: resolved ? resolvedWritable(data) : readOnly ? [] : active.map((c) => c.name),
+      settable: resolved ? resolvedWritable(data).filter((name2) => !primaryKey.includes(name2)) : readOnly ? [] : active.filter((c) => !c.onUpdateFn).map((c) => c.name),
+      appendable: readOnly ? [] : active.filter((c) => c.type === "jsonb").map((c) => c.name),
       ...touchOnUpdate.length > 0 ? { touchOnUpdate } : {},
       ...cells ? { cells } : {},
       ...resolved ? { resolved: resolvedMeta({ resolved, pk: primaryKey[0] }) } : {},
@@ -2916,6 +3129,16 @@ function buildCompileContext(rawCanonical) {
         });
         continue;
       }
+      const identityTable = link.kind === "toOne" ? targetName : link.kind === "toMany" ? table.table : void 0;
+      if (identityTable !== void 0 && unkeyedSyncedTableNames.has(identityTable)) {
+        diagnostics.push({
+          severity: "error",
+          code: "unkeyed-link-identity",
+          table: table.table,
+          message: `link '${link.name}' cannot use unkeyed table '${identityTable}' as a row identity`
+        });
+        continue;
+      }
       const targetEntries = targetName === PLATFORM_USER_TABLE ? target.columns.map((c) => ({ ...c, deprecated: false, onUpdateFn: false })) : columnEntries.get(targetName);
       const onEntries = link.kind === "toMany" ? targetEntries : entries;
       const referencesEntries = link.kind === "toMany" ? entries : targetEntries;
@@ -2981,7 +3204,7 @@ function buildCompileContext(rawCanonical) {
     compilePolicyFor("write", writePolicies);
     compilePolicyFor("insert", insertPolicies);
     compilePolicyFor("update", updatePolicies);
-    if (isView && table.resolved === void 0) {
+    if (isView && table.resolved === void 0 || unkeyedSyncedTableNames.has(table.table)) {
       writePolicies.set(table.table, CONST_FALSE);
       insertPolicies.set(table.table, CONST_FALSE);
       updatePolicies.set(table.table, CONST_FALSE);
@@ -3056,7 +3279,7 @@ function buildCompileContext(rawCanonical) {
   const queryRoots = /* @__PURE__ */ new Map();
   const mutationRoots = /* @__PURE__ */ new Map();
   for (const table of relations) {
-    if (table.internal === true) continue;
+    if (table.internal === true || unkeyedSyncedTableNames.has(table.table)) continue;
     const roots = queryRootNames(table.table);
     queryRoots.set(roots.select, { kind: "select", table: table.table });
     if ((tables[table.table]?.primaryKey.length ?? 0) > 0) {
@@ -3436,8 +3659,10 @@ var OperationLowerer = class {
   constructor(ctx, restricted) {
     this.ctx = ctx;
     this.variables = new Map(restricted.variables.map((v) => [v.name, v]));
+    this.maxRows = restricted.readBudget ?? MAX_LIMIT;
   }
   variables;
+  maxRows;
   meta(table) {
     return this.ctx.tables[table];
   }
@@ -3641,13 +3866,13 @@ var OperationLowerer = class {
     });
   }
   lowerLimit(node) {
-    const base2 = { default: DEFAULT_LIMIT, max: MAX_LIMIT };
+    const base2 = { default: DEFAULT_LIMIT, max: this.maxRows };
     if (!node) return base2;
     if (node.kind === Kind.VARIABLE) return { ...base2, variable: node.name.value };
     if (node.kind === Kind.INT) {
       const value = Number(node.value);
       if (value < 1) fail2("limit must be a positive integer", "invalid-limit");
-      return { ...base2, value: Math.min(value, MAX_LIMIT) };
+      return { ...base2, value: Math.min(value, this.maxRows) };
     }
     fail2("limit must be an integer literal or a variable", "invalid-limit");
   }
@@ -4446,7 +4671,13 @@ var OperationLowerer = class {
 };
 function lowerOperation({ restricted, ctx }) {
   const lowerer = new OperationLowerer(ctx, restricted);
-  return lowerer.lowerRoots(restricted.definition, restricted.kind);
+  const roots = lowerer.lowerRoots(restricted.definition, restricted.kind);
+  if (restricted.readBudget === void 0) return roots;
+  const root = roots[0];
+  if (restricted.kind !== "query" || restricted.definition.selectionSet.selections.length !== 1 || roots.length !== 1 || root?.kind !== "select" || root.selection.relations.length > 0 || root.selection.aggregates.length > 0 || root.selection.cells !== void 0 || root.prefetch?.length) {
+    fail2("@readBudget requires one flat select root without related selections, aggregates, cells, or prefetch", "invalid-read-budget");
+  }
+  return roots;
 }
 function isCellColumn(meta, name2) {
   if (!meta.cells) return false;
@@ -4505,6 +4736,19 @@ function parseDocuments({
   }
   return { documents: parsed, diagnostics };
 }
+function parseReadBudget(operation) {
+  const directives = operation.directives?.filter((directive) => directive.name.value === "readBudget") ?? [];
+  if (directives.length === 0) return void 0;
+  const value = directives[0]?.arguments?.find((argument) => argument.name.value === "maxRows")?.value;
+  if (operation.operation !== "query" || directives.length !== 1 || value?.kind !== Kind.INT) {
+    throw new DocumentCompileError("@readBudget requires a literal maxRows on a query", "invalid-read-budget");
+  }
+  const maxRows = Number(value.value);
+  if (!Number.isSafeInteger(maxRows) || maxRows < 1 || maxRows > MAX_PERSISTED_READ_ROWS) {
+    throw new DocumentCompileError(`@readBudget(maxRows:) must be between 1 and ${MAX_PERSISTED_READ_ROWS}`, "invalid-read-budget");
+  }
+  return maxRows;
+}
 function unwrapType(node, variable) {
   let nullable = true;
   let list2 = false;
@@ -4665,6 +4909,7 @@ function restrictOperation({
     name: name2,
     kind: operation.operation === "mutation" ? "mutation" : "query",
     requires: parseRequires(operation),
+    readBudget: parseReadBudget(operation),
     variables,
     definition: operation
   };
@@ -5178,9 +5423,9 @@ function compilePredIrToSql(pred, options = {}) {
     case "cmp":
       return compileCmp(pred.op, pred.column, pred.value, options);
     case "capability":
-      return `(${capabilityExpression(pred.key, pred.namespace ?? options.namespace)})`;
+      return `(${options.statementClaimChecks ? "SELECT " : ""}${capabilityExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "role":
-      return `(${roleExpression(pred.key, pred.namespace ?? options.namespace)})`;
+      return `(${options.statementClaimChecks ? "SELECT " : ""}${roleExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "exists":
       if (options.exists) return options.exists(pred);
       throw new OrmDefinitionError("synced view read policy cannot use 'exists' without a relationship resolver");
@@ -5288,7 +5533,8 @@ function createSqlCatalog({ canonical, publishedObjects, executionTarget }) {
   const { ctx, diagnostics } = buildCompileContext(canonical);
   if (diagnostics.some((d) => d.severity === "error")) throw new Error(diagnostics.map((d) => d.message).join("; "));
   const identity = sqlHash(`ontology-sql-v1\0${computeSchemaHash(canonical)}\0${executionTarget}`);
-  const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${meta.table}`;
+  const logicalNames = new Map(Object.entries(ctx.tables).map(([key, meta]) => [meta, key]));
+  const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${logicalNames.get(meta)}`;
   const definitions = [canonical, ...canonical.imports ?? []];
   const internal = new Set(definitions.flatMap((owner) => [
     ...owner.tables.filter((t) => t.internal).map((t) => `${owner.namespace}/${t.table}`),
@@ -5364,15 +5610,48 @@ function only(node, keys) {
 var parser;
 var SQL_TYPES = ["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"];
 var pgType = (type) => type === "double" ? "double precision" : SQL_TYPES.some((t) => t === type) ? type : fail3("unsupported SQL type");
-async function compileOntologySql({ catalog, sql, parameterTypes = [], maxRows = 1e3 }) {
-  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > 1e4 || Buffer.byteLength(sql) > 65536) fail3("SQL limit exceeded");
+async function parseSelect(sql) {
+  if (Buffer.byteLength(sql) > 65536) fail3("SQL limit exceeded");
   parser ??= new PgParser({ version: 17 });
   const parsed = await parser.parse(sql);
   if (parsed.error || !parsed.tree) fail3("invalid SQL");
   const statements = list(obj(parsed.tree).stmts);
   if (statements.length !== 1) fail3("one SQL SELECT is required");
+  const statement = obj(obj(statements[0]).stmt);
+  if (!statement.SelectStmt) fail3("one SQL SELECT is required");
+  return statement;
+}
+async function referencedSqlObjects({ sql }) {
+  const objects = /* @__PURE__ */ new Set();
+  let nodes = 0;
+  function visit2(value, depth) {
+    if (++nodes > 1e4 || depth > 96) fail3("SQL complexity limit exceeded");
+    if (Array.isArray(value)) {
+      for (const child of value) visit2(child, depth + 1);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    const node = obj(value);
+    if (node.RangeVar) {
+      const range = obj(node.RangeVar);
+      if (range.schemaname) {
+        const namespace = str(range.schemaname), name2 = str(range.relname);
+        if (!/^[a-z][a-z0-9_]{0,40}$/.test(namespace) || namespace === "pg_catalog" || namespace === "information_schema") fail3("invalid ontology namespace");
+        objects.add(`${namespace}/${name2}`);
+        if (objects.size > 256) fail3("too many SQL objects");
+      }
+    }
+    for (const child of Object.values(node)) visit2(child, depth + 1);
+  }
+  visit2(await parseSelect(sql), 0);
+  if (!objects.size) fail3("SQL operation must read an ontology object");
+  return [...objects].sort();
+}
+async function compileOntologySql({ catalog, sql, parameterTypes = [], maxRows = 1e3 }) {
+  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > 1e4 || Buffer.byteLength(sql) > 65536) fail3("SQL limit exceeded");
+  const statement = await parseSelect(sql);
   const emitter = new SqlEmitter({ catalog, parameterTypes });
-  const result = emitter.select(obj(obj(statements[0]).stmt), { relations: [], ctes: /* @__PURE__ */ new Map() });
+  const result = emitter.select(statement, { relations: [], ctes: /* @__PURE__ */ new Map() });
   if (emitter.used.size !== parameterTypes.length) fail3("SQL parameters must be used exactly as declared");
   if (!emitter.read.size) fail3("SQL operation must read an ontology object");
   return {
@@ -5705,6 +5984,118 @@ function bindNamedParameters({ sql, names }) {
   }
   return result;
 }
+var parser2;
+var functions = new Set(VIEW_QUERY_FUNCTION_ALLOWLIST);
+var scalarTypes = /* @__PURE__ */ new Set([
+  "bool",
+  "boolean",
+  "int2",
+  "int4",
+  "int8",
+  "integer",
+  "bigint",
+  "smallint",
+  "numeric",
+  "decimal",
+  "float4",
+  "float8",
+  "real",
+  "text",
+  "varchar",
+  "bpchar",
+  "uuid",
+  "date",
+  "timestamp",
+  "timestamptz",
+  "time",
+  "timetz",
+  "interval",
+  "json",
+  "jsonb",
+  "bytea"
+]);
+var sqlValues = /* @__PURE__ */ new Set([
+  "SVFOP_CURRENT_DATE",
+  "SVFOP_CURRENT_TIME",
+  "SVFOP_CURRENT_TIME_N",
+  "SVFOP_CURRENT_TIMESTAMP",
+  "SVFOP_CURRENT_TIMESTAMP_N",
+  "SVFOP_LOCALTIME",
+  "SVFOP_LOCALTIME_N",
+  "SVFOP_LOCALTIMESTAMP",
+  "SVFOP_LOCALTIMESTAMP_N",
+  "SVFOP_CURRENT_ROLE",
+  "SVFOP_CURRENT_USER",
+  "SVFOP_USER",
+  "SVFOP_SESSION_USER",
+  "SVFOP_CURRENT_CATALOG",
+  "SVFOP_CURRENT_SCHEMA"
+]);
+async function validateManagedViewQueries({ canonical }) {
+  for (const definition of [canonical, ...canonical.imports ?? []]) {
+    for (const view of definition.views ?? []) {
+      const fail4 = (message) => {
+        throw new OrmDefinitionError(`managed view '${definition.namespace}/${view.view}': ${message}`);
+      };
+      parser2 ??= new PgParser({ version: 17 });
+      const parsed = await parser2.parse(view.query);
+      if (parsed.error || !parsed.tree) fail4("invalid SELECT query");
+      const statements = list(obj(parsed.tree).stmts);
+      if (statements.length !== 1 || !obj(obj(statements[0]).stmt).SelectStmt) fail4("one SELECT query is required");
+      validateTree({ tree: parsed.tree, schema: ormSchemaName(definition.namespace), enums: definition.enums.map((entry) => entry.name), fail: fail4 });
+    }
+  }
+}
+function pgCatalogName(parts) {
+  if (parts.length === 1) return parts[0];
+  if (parts.length === 2 && parts[0] === "pg_catalog") return parts[1];
+  return void 0;
+}
+function reviewedFunctionName({ parts, format }) {
+  return format === "COERCE_SQL_SYNTAX" && parts.length === 2 && parts[0] === "pg_catalog" && parts[1] === "position" ? "strpos" : pgCatalogName(parts);
+}
+function validateTree({ tree, ...scope }) {
+  const pending = [tree];
+  while (pending.length) {
+    const value = pending.pop();
+    if (Array.isArray(value)) {
+      pending.push(...value);
+      continue;
+    }
+    if (!value || typeof value !== "object") continue;
+    const node = obj(value);
+    for (const [kind, child] of Object.entries(node)) {
+      validateNode({ kind, child, scope });
+      pending.push(child);
+    }
+  }
+}
+function validateNode({ kind, child, scope }) {
+  const { fail: fail4 } = scope;
+  if (kind.endsWith("Stmt") && kind !== "SelectStmt") fail4("only SELECT statements are permitted");
+  if (kind === "FuncCall") {
+    const call = obj(child);
+    const parts = strings(call.funcname);
+    const name2 = reviewedFunctionName({ parts, format: call.funcformat });
+    if (!name2 || !functions.has(name2)) fail4(`only explicitly allowlisted pg_catalog functions are permitted (found '${parts.join(".")}')`);
+  }
+  if (kind === "typeName" || kind === "TypeName") validateType({ node: obj(child), ...scope });
+  if (kind === "A_Expr" && pgCatalogName(strings(obj(child).name)) === void 0) fail4("only pg_catalog operators are permitted");
+  if (kind === "SortBy" && list(obj(child).useOp).length && pgCatalogName(strings(obj(child).useOp)) === void 0) fail4("only pg_catalog sort operators are permitted");
+  if (kind === "SQLValueFunction" && !sqlValues.has(String(obj(child).op))) fail4("unsupported SQL value expression");
+  if (kind === "ParamRef") fail4("view queries cannot contain parameters");
+  if (kind === "A_Indirection" && list(obj(child).indirection).some((entry) => !obj(entry).A_Indices)) {
+    fail4("composite field notation is not permitted in managed views");
+  }
+}
+function validateType({ node, schema, enums, fail: fail4 }) {
+  const parts = strings(node.names);
+  const builtin = pgCatalogName(parts);
+  const managedEnum = parts.length === 1 && enums.includes(parts[0]) || parts.length === 2 && parts[0] === schema && enums.includes(parts[1]);
+  if (node.setof || node.pct_type || !managedEnum && (!builtin || !scalarTypes.has(builtin))) {
+    fail4(`casts may only use supported pg_catalog scalar types or declared enums (found '${parts.join(".")}')`);
+  }
+}
 
 // src/sql/operations.ts
 function isSqlOperationDocument(path, contents) {
@@ -5720,7 +6111,13 @@ function isSqlOperationDocument(path, contents) {
 async function compileOperationDocuments(input) {
   const sqlDocuments = input.documents.filter((d) => isSqlOperationDocument(d.path, d.contents));
   const result = compileNamespace({ ...input, documents: input.documents.filter((d) => !isSqlOperationDocument(d.path, d.contents)) });
-  if (!result.ok || !sqlDocuments.length) return result;
+  if (!result.ok) return result;
+  const viewDiagnostics = await managedViewDiagnostics(input.canonical);
+  if (viewDiagnostics.length) return { ok: false, diagnostics: [...result.diagnostics, ...viewDiagnostics] };
+  if (!sqlDocuments.length) return result;
+  return compileSqlDocuments({ input, result, sqlDocuments });
+}
+async function compileSqlDocuments({ input, result, sqlDocuments }) {
   for (const document of sqlDocuments) {
     try {
       const definition = defineOperation(JSON.parse(document.contents));
@@ -5814,6 +6211,18 @@ async function compileOperationDocuments(input) {
   result.manifest.opsHash = result.artifact.opsHash;
   return { ...result, artifact: normalizeIr(result.artifact) };
 }
+async function managedViewDiagnostics(canonical) {
+  try {
+    await validateManagedViewQueries({ canonical });
+    return [];
+  } catch (error) {
+    return [{
+      severity: "error",
+      code: "invalid-view-query",
+      message: error instanceof Error ? error.message : "invalid managed view query"
+    }];
+  }
+}
 var parameterName = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(63).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "reserved parameter name");
 var parameter = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), value: z.string().nullable() }).strict(),
@@ -5830,7 +6239,7 @@ var sqlQueryInputSchema = z.object({
   sql: z.string().min(1).max(65536).refine((value) => Buffer.byteLength(value) <= 65536, "SQL exceeds 64 KiB"),
   parameters: z.record(parameterName, parameter).refine((value) => Object.keys(value).length <= 128, "too many SQL parameters").default({})
 }).strict();
-async function compileRuntimeSql({ operation, input }) {
+async function compileRuntimeSql({ operation, input, qualified = false }) {
   const contract = operation.sqlQuery;
   if (!contract) throw new Error("missing runtime SQL contract");
   const names = Object.keys(input.parameters).sort();
@@ -5846,10 +6255,87 @@ async function compileRuntimeSql({ operation, input }) {
     sqlQuery: void 0,
     irVersion: SQL_IR_VERSION,
     variables: names.map((name2) => ({ name: name2, type: { kind: "scalar", scalar: input.parameters[name2].type }, nullable: true, list: false })),
-    tableSet: plan.read.map((ref) => ref.split("/")[1]).sort(),
+    tableSet: qualified ? plan.read : plan.read.map((ref) => ref.split("/")[1]).sort(),
     sql: { text: plan.text, columns: plan.columns, parameters: names, read: plan.read, maxRows: plan.maxRows }
   });
 }
+
+// src/sql/builtin.ts
+function localHash(definition) {
+  const { imports: _imports, ...local } = definition;
+  return computeSchemaHash(normalizeCanonical(local));
+}
+function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjects = [], executionTarget = "default" }) {
+  const anchor = definitions.find((definition) => definition.namespace === namespace);
+  if (!anchor) throw new Error("missing SQL namespace definition");
+  const tables = {};
+  const policies = {};
+  const objects = [];
+  for (const definition of definitions) {
+    const owner = definition.namespace;
+    const { ctx, diagnostics } = buildCompileContext(definition);
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) throw new Error("SQL namespace definition is invalid");
+    const ref = (key) => {
+      const meta = ctx.tables[key];
+      if (!meta) throw new Error("SQL dependency is unavailable");
+      return `${meta.namespace ?? owner}/${key}`;
+    };
+    for (const [key, meta] of Object.entries(ctx.tables)) {
+      if ((meta.namespace ?? owner) !== owner) continue;
+      const identity = ref(key);
+      tables[identity] = {
+        ...meta,
+        namespace: owner,
+        links: meta.links.map((link) => ({ ...link, ...link.target ? { target: ref(link.target) } : {} })),
+        ...meta.dependencies ? { dependencies: meta.dependencies.map(ref) } : {},
+        ...meta.foreignReferences ? { foreignReferences: meta.foreignReferences.map((link) => ({ ...link, target: ref(link.target) })) } : {}
+      };
+      const policy = ctx.readPolicies.get(key);
+      if (policy) policies[identity] = policy;
+    }
+    const selected = read.filter((identity) => identity.startsWith(`${owner}/`));
+    if (!selected.length) continue;
+    if (owner !== namespace && selected.some((identity) => !definition.exports?.[identity.slice(owner.length + 1)]?.read)) {
+      throw new Error("SQL object is not exported");
+    }
+    objects.push(...createSqlCatalog({ canonical: definition, publishedObjects: selected, executionTarget }).objects);
+  }
+  if (objects.length !== read.length) throw new Error("SQL object is unavailable");
+  const actualRead = [...new Set(objects.flatMap((object) => object.read))].sort();
+  const catalog = { objects, identity: sqlHash(JSON.stringify([
+    "builtin-sql-catalog-v1",
+    namespace,
+    executionTarget,
+    read,
+    definitions.map((definition) => [definition.namespace, computeSchemaHash(definition)]).sort()
+  ])) };
+  return normalizeIr({
+    irVersion: RUNTIME_SQL_IR_VERSION,
+    namespace,
+    schemaHash: catalog.identity,
+    ownSchemaHash: localHash(anchor),
+    opsHash: BUILTIN_SQL_READ_HASH,
+    dependencies: Object.fromEntries(definitions.filter((definition) => definition.namespace !== namespace).map((definition) => [definition.namespace, localHash(definition)])),
+    tables,
+    readPolicies: policies,
+    unbackedTables: [...unbackedObjects],
+    operations: { BuiltinSqlRead: {
+      irVersion: RUNTIME_SQL_IR_VERSION,
+      name: "BuiltinSqlRead",
+      opHash: BUILTIN_SQL_READ_HASH,
+      language: "sql",
+      kind: "query",
+      requires: null,
+      roots: [],
+      tableSet: actualRead,
+      variables: [
+        { name: "sql", type: { kind: "scalar", scalar: "text" }, nullable: false, list: false },
+        { name: "parameters", type: { kind: "scalar", scalar: "jsonb" }, nullable: true, list: false }
+      ],
+      sqlQuery: { catalog, read: actualRead, maxRows: 1e3 }
+    } }
+  });
+}
 var DATASET_PREVIEW_LIMIT = 100;
 function compileDatasetPreviews(input) {
   const canonical = normalizeCanonical(input);
@@ -5895,6 +6381,6 @@ function compileDatasetPreviews(input) {
   return operations;
 }
 
-export { COMPILER_MAJOR, CONST_TRUE, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, DocumentCompileError, MAX_LIMIT, NamespaceCompileError, ORDER_BY_DIRECTIONS, OperationLowerer, PLATFORM_USER_TABLE, PLATFORM_USER_TYPENAME, POLICY_COMPARE_OPS, POLICY_MAX_LINK_DEPTH, PolicyCompileError, PolicyParseError, allowedBoolExpOperators, allowedOps, andPred, assertClaimsOnlyWhen, buildCompileContext, camelCase, canonicalOperationText, classifyInputType, collectPinnedColumns, compileDatasetPreviews, compileNamespace, compileNamespaceOrThrow, compileOperationDocuments, compilePolicy, compilePredicateV2, compileRuntimeSql, computeOpHash, computeOpsHash, computePinnedColumnsByTable, computeSchemaHash, defineOperation, enumTypeName, flattenOperation, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, parseDocuments, parsePolicy, parseSdl, pascalCase, platformUserMeta, predContains, predContainsExists, queryRootNames, restrictOperation, sqlOperationDefinitionSchema, sqlQueryInputSchema, typeNameForTable, validateAppendInput, validateBoolExpInput, validateInsertInput, validateOnConflictInput, validateOrderByInput, validateSelectColumns, validateSetInput, walkPolicy, walkPred };
+export { COMPILER_MAJOR, CONST_TRUE, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, DocumentCompileError, MAX_LIMIT, NamespaceCompileError, ORDER_BY_DIRECTIONS, OperationLowerer, PLATFORM_USER_TABLE, PLATFORM_USER_TYPENAME, POLICY_COMPARE_OPS, POLICY_MAX_LINK_DEPTH, PolicyCompileError, PolicyParseError, allowedBoolExpOperators, allowedOps, andPred, assertClaimsOnlyWhen, bindNamedParameters, buildCompileContext, camelCase, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileNamespace, compileNamespaceOrThrow, compileOperationDocuments, compilePolicy, compilePredicateV2, compileRuntimeSql, computeOpHash, computeOpsHash, computePinnedColumnsByTable, computeSchemaHash, defineOperation, enumTypeName, flattenOperation, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, parseDocuments, parsePolicy, parseSdl, pascalCase, platformUserMeta, predContains, predContainsExists, queryRootNames, referencedSqlObjects, restrictOperation, sqlOperationDefinitionSchema, sqlQueryInputSchema, typeNameForTable, validateAppendInput, validateBoolExpInput, validateInsertInput, validateManagedViewQueries, validateOnConflictInput, validateOrderByInput, validateSelectColumns, validateSetInput, walkPolicy, walkPred };
 //# sourceMappingURL=compiler.js.map
 //# sourceMappingURL=compiler.js.map