@sequenceholdings/orm 2.5.0 → 2.6.1

package/README.md

@@ -131,6 +131,29 @@ Execute uses the `/_data/v2` endpoint by default. Set
 `SEQUENCE_ORM_ATLAS_EXECUTE_V2=1` to opt into Atlas's `/api/data/v2` endpoint.
 This client rollout switch does not bypass server feature flags or authorization.
 
+## Default read-only SQL (planned 2.6.0)
+
+With the matching SDK and Atlas rollout, every active v2 namespace supports
+runtime-supplied SQL without an authored operation or Function:
+
+```ts
+const orm = createArtifactOrmExecutor({ namespace: 'lending' })
+const result = await orm.sql({
+  sql: `SELECT l.id, c.name FROM lending.loans l
+    JOIN party.customers c ON c.id = l."customerId"
+    WHERE c.type = :type`,
+  parameters: { type: { type: 'text', value: 'retail' } },
+})
+```
+
+Functions use `createFunctionOrmExecutor({ request, baseUrl, namespace })` and
+the same `sql()` method. Namespace access, object policies, foreign exports,
+delegated table scopes and optional consumer contracts still apply. Queries are
+read-only, restricted to supported SELECT syntax, and capped at 1,000 rows / 8 MiB.
+Separate protected execution targets cannot be joined. Existing registered
+operations remain supported; supply a manifest when executing them by name.
+Source versions alone do not prove package publication or server availability.
+
 ## Public exports
 
 - `@sequenceholdings/orm/authoring` — namespace, table, policy, and view DSL

package/dist/cli.cjs

@@ -1458,6 +1458,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;
@@ -1791,7 +1794,8 @@ var compiledOperationSchema = zod.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) {
@@ -5173,9 +5177,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");
@@ -5283,7 +5287,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((t2) => t2.internal).map((t2) => `${owner.namespace}/${t2.table}`),
@@ -5359,15 +5364,22 @@ 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((t2) => t2 === type) ? type : fail3("unsupported SQL type");
-async function compileOntologySql({ catalog, sql: sql4, parameterTypes = [], maxRows = 1e3 }) {
-  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > 1e4 || Buffer.byteLength(sql4) > 65536) fail3("SQL limit exceeded");
+async function parseSelect(sql4) {
+  if (Buffer.byteLength(sql4) > 65536) fail3("SQL limit exceeded");
   parser ??= new pgParser.PgParser({ version: 17 });
   const parsed = await parser.parse(sql4);
   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 compileOntologySql({ catalog, sql: sql4, parameterTypes = [], maxRows = 1e3 }) {
+  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > 1e4 || Buffer.byteLength(sql4) > 65536) fail3("SQL limit exceeded");
+  const statement = await parseSelect(sql4);
   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 {
@@ -7786,19 +7798,19 @@ function compileComparison(op, left, right, columnTypes) {
   }
   return `${compileOperand(left, right, columnTypes)} ${SQL_COMPARE_OPS[op]} ${compileOperand(right, left, columnTypes)}`;
 }
-function compilePredicate(predicate, columnTypes) {
+function compilePredicate(predicate, columnTypes, options = {}) {
   switch (predicate.kind) {
     case "and":
     case "or": {
-      const joined = predicate.operands.map((operand) => compilePredicate(operand, columnTypes)).join(` ${predicate.kind.toUpperCase()} `);
+      const joined = predicate.operands.map((operand) => compilePredicate(operand, columnTypes, options)).join(` ${predicate.kind.toUpperCase()} `);
       return `(${joined})`;
     }
     case "not":
-      return `(NOT ${compilePredicate(predicate.operand, columnTypes)})`;
+      return `(NOT ${compilePredicate(predicate.operand, columnTypes, options)})`;
     case "compare":
       return `(${compileComparison(predicate.op, predicate.left, predicate.right, columnTypes)})`;
     case "capability":
-      return `(${capabilityExpression(predicate.key)})`;
+      return `(${options.statementClaimChecks ? "SELECT " : ""}${capabilityExpression(predicate.key)})`;
   }
 }