@mauroandre/weave-sdk 0.0.1

package/dist/chunk-PWTED7ZO.js

@@ -0,0 +1,767 @@
+// ../core/src/schema/column.ts
+var Column = class _Column {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  /** Mark the column `NOT NULL` — narrows the read type from `T | null` to `T`. */
+  notNull() {
+    return new _Column({ ...this.config, notNull: true });
+  }
+  /** Mark the column nullable — widens the read type back to `T | null`. */
+  nullable() {
+    return new _Column({ ...this.config, notNull: false });
+  }
+  /** Declare a default value — makes the column optional on insert. */
+  default(value) {
+    return new _Column({ ...this.config, hasDefault: true, default: value });
+  }
+  /** Add a single-column `UNIQUE`. */
+  unique() {
+    return new _Column({ ...this.config, unique: true });
+  }
+  /** Add a single-column index. */
+  index() {
+    return new _Column({ ...this.config, index: true });
+  }
+  /** Pin a stable field id (survives rename). Normally emitted by `weave gen`. */
+  $id(id) {
+    return new _Column({ ...this.config, id });
+  }
+};
+function scalarColumn(pgType) {
+  return new Column({
+    pgType,
+    isArray: false,
+    notNull: false,
+    hasDefault: false,
+    unique: false,
+    index: false
+  });
+}
+
+// ../core/src/schema/owned.ts
+var Owned = class _Owned {
+  constructor(shape, cardinality, options, id) {
+    this.shape = shape;
+    this.cardinality = cardinality;
+    this.options = options;
+    this.id = id;
+  }
+  shape;
+  cardinality;
+  options;
+  id;
+  kind = "owned";
+  /** Pin a stable field id (survives rename). Normally emitted by `weave gen`. */
+  $id(id) {
+    return new _Owned(this.shape, this.cardinality, this.options, id);
+  }
+};
+var OwnedArray = class {
+  constructor(shape) {
+    this.shape = shape;
+  }
+  shape;
+  kind = "owned_array";
+};
+function owned(arg, options = {}) {
+  if (arg instanceof OwnedArray) {
+    return new Owned(arg.shape, "many", options);
+  }
+  return new Owned(arg, "one", options);
+}
+
+// ../core/src/schema/reference.ts
+var Reference = class _Reference {
+  constructor(target, cardinality, isNotNull, id) {
+    this.target = target;
+    this.cardinality = cardinality;
+    this.isNotNull = isNotNull;
+    this.id = id;
+  }
+  target;
+  cardinality;
+  isNotNull;
+  id;
+  kind = "reference";
+  /** Make the FK `NOT NULL` (only meaningful for N:1). */
+  notNull() {
+    return new _Reference(this.target, this.cardinality, true, this.id);
+  }
+  /** Pin a stable field id (survives rename). Normally emitted by `weave gen`. */
+  $id(id) {
+    return new _Reference(this.target, this.cardinality, this.isNotNull, id);
+  }
+};
+var ReferenceArray = class {
+  constructor(target) {
+    this.target = target;
+  }
+  target;
+  kind = "reference_array";
+};
+function reference(arg) {
+  if (arg instanceof ReferenceArray) {
+    return new Reference(arg.target, "many", false);
+  }
+  return new Reference(arg, "one", false);
+}
+
+// ../core/src/types/pg-type.ts
+function defineType() {
+  return (def) => ({
+    ...def,
+    // Phantom: exists only so the compiler can recover `TTs`. Never read at runtime.
+    tsType: void 0
+  });
+}
+
+// ../core/src/types/catalog.ts
+var int2 = defineType()({ name: "int2", sqlType: "smallint", oid: 21, tsLabel: "number" });
+var int4 = defineType()({ name: "int4", sqlType: "integer", oid: 23, tsLabel: "number" });
+var int8 = defineType()({ name: "int8", sqlType: "bigint", oid: 20, tsLabel: "bigint" });
+var numeric = defineType()({ name: "numeric", sqlType: "numeric", oid: 1700, tsLabel: "number" });
+var float4 = defineType()({ name: "float4", sqlType: "real", oid: 700, tsLabel: "number" });
+var float8 = defineType()({ name: "float8", sqlType: "double precision", oid: 701, tsLabel: "number" });
+var text = defineType()({ name: "text", sqlType: "text", oid: 25, tsLabel: "string" });
+var varchar = defineType()({ name: "varchar", sqlType: "varchar", oid: 1043, tsLabel: "string" });
+var bpchar = defineType()({ name: "bpchar", sqlType: "char", oid: 1042, tsLabel: "string" });
+var timestamptz = defineType()({ name: "timestamptz", sqlType: "timestamp with time zone", oid: 1184, tsLabel: "Date" });
+var timestamp = defineType()({ name: "timestamp", sqlType: "timestamp", oid: 1114, tsLabel: "Date" });
+var date = defineType()({ name: "date", sqlType: "date", oid: 1082, tsLabel: "Date" });
+var time = defineType()({ name: "time", sqlType: "time", oid: 1083, tsLabel: "string" });
+var interval = defineType()({ name: "interval", sqlType: "interval", oid: 1186, tsLabel: "string" });
+var bool = defineType()({ name: "bool", sqlType: "boolean", oid: 16, tsLabel: "boolean" });
+var uuid = defineType()({ name: "uuid", sqlType: "uuid", oid: 2950, tsLabel: "string" });
+var json = defineType()({ name: "json", sqlType: "json", oid: 114, tsLabel: "unknown" });
+var jsonb = defineType()({ name: "jsonb", sqlType: "jsonb", oid: 3802, tsLabel: "unknown" });
+var bytea = defineType()({ name: "bytea", sqlType: "bytea", oid: 17, tsLabel: "Uint8Array" });
+
+// ../core/src/types/registry.ts
+var catalog = {
+  int2,
+  int4,
+  int8,
+  numeric,
+  float4,
+  float8,
+  text,
+  varchar,
+  bpchar,
+  timestamptz,
+  timestamp,
+  date,
+  time,
+  interval,
+  bool,
+  uuid,
+  json,
+  jsonb,
+  bytea
+};
+var allTypes = Object.values(catalog);
+var byName = new Map(
+  allTypes.map((t) => [t.name, t])
+);
+var byOid = new Map(
+  allTypes.map((t) => [t.oid, t])
+);
+
+// ../core/src/schema/scalars.ts
+var int22 = () => scalarColumn(catalog.int2);
+var int42 = () => scalarColumn(catalog.int4);
+var int82 = () => scalarColumn(catalog.int8);
+var numeric2 = () => scalarColumn(catalog.numeric);
+var float42 = () => scalarColumn(catalog.float4);
+var float82 = () => scalarColumn(catalog.float8);
+var text2 = () => scalarColumn(catalog.text);
+var varchar2 = () => scalarColumn(catalog.varchar);
+var bpchar2 = () => scalarColumn(catalog.bpchar);
+var timestamptz2 = () => scalarColumn(catalog.timestamptz);
+var timestamp2 = () => scalarColumn(catalog.timestamp);
+var date2 = () => scalarColumn(catalog.date);
+var time2 = () => scalarColumn(catalog.time);
+var interval2 = () => scalarColumn(catalog.interval);
+var bool2 = () => scalarColumn(catalog.bool);
+var uuid2 = () => scalarColumn(catalog.uuid);
+var json2 = () => scalarColumn(catalog.json);
+var jsonb2 = () => scalarColumn(catalog.jsonb);
+var bytea2 = () => scalarColumn(catalog.bytea);
+function array(arg) {
+  if (arg instanceof Column) {
+    return new Column({
+      pgType: arg.config.pgType,
+      isArray: true,
+      notNull: true,
+      hasDefault: true,
+      default: [],
+      unique: false,
+      index: false
+    });
+  }
+  const candidate = arg;
+  if (typeof candidate.name === "string" && typeof candidate.columns === "object") {
+    return new ReferenceArray(arg);
+  }
+  return new OwnedArray(arg);
+}
+
+// ../core/src/schema/entity.ts
+function defineEntity(name, columns) {
+  return { name, columns };
+}
+
+// ../core/src/ir/to-ir.ts
+function toIR(entity) {
+  return { irVersion: 1, name: entity.name, fields: shapeToIR(entity.columns) };
+}
+function shapeToIR(shape) {
+  const out = {};
+  for (const [key, node] of Object.entries(shape)) out[key] = nodeToIR(node);
+  return out;
+}
+function nodeToIR(node) {
+  if (node instanceof Column) {
+    const c = node.config;
+    const ir = { kind: "column", type: c.pgType.name };
+    if (c.id) ir.id = c.id;
+    if (c.isArray) ir.array = true;
+    if (c.notNull) ir.notNull = true;
+    if (c.hasDefault) ir.default = c.default;
+    if (c.unique) ir.unique = true;
+    if (c.index) ir.index = true;
+    return ir;
+  }
+  if (node instanceof Reference) {
+    const ir = {
+      kind: "reference",
+      target: node.target.name,
+      cardinality: node.cardinality
+    };
+    if (node.id) ir.id = node.id;
+    if (node.isNotNull) ir.notNull = true;
+    return ir;
+  }
+  if (node instanceof Owned) {
+    const ir = {
+      kind: "owned",
+      array: node.cardinality === "many",
+      shape: shapeToIR(node.shape)
+    };
+    if (node.id) ir.id = node.id;
+    if (node.options.table !== void 0) ir.table = node.options.table;
+    return ir;
+  }
+  throw new Error("toIR \u2014 n\xF3 desconhecido no shape (esperado Column/Owned/Reference).");
+}
+
+// src/errors.ts
+var WeaveError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "WeaveError";
+  }
+  status;
+};
+var WeaveAuthError = class extends WeaveError {
+  constructor(message) {
+    super(message, 401);
+    this.name = "WeaveAuthError";
+  }
+};
+var WeaveScopeError = class extends WeaveError {
+  constructor(message) {
+    super(message, 403);
+    this.name = "WeaveScopeError";
+  }
+};
+var WeaveNotFoundError = class extends WeaveError {
+  constructor(message) {
+    super(message, 404);
+    this.name = "WeaveNotFoundError";
+  }
+};
+var WeaveValidationError = class extends WeaveError {
+  constructor(message) {
+    super(message, 400);
+    this.name = "WeaveValidationError";
+  }
+};
+function errorFor(status, message) {
+  switch (status) {
+    case 401:
+      return new WeaveAuthError(message);
+    case 403:
+      return new WeaveScopeError(message);
+    case 404:
+      return new WeaveNotFoundError(message);
+    case 400:
+      return new WeaveValidationError(message);
+    default:
+      return new WeaveError(message, status);
+  }
+}
+
+// src/push.ts
+async function fetchIR(transport, base, key, name) {
+  const res = await transport(
+    new Request(`${base}/admin/entities/${encodeURIComponent(name)}`, { method: "GET", headers: { "x-api-key": key } })
+  );
+  if (!res.ok) return null;
+  return await res.json().catch(() => null);
+}
+function depsOf(ir) {
+  const deps = /* @__PURE__ */ new Set();
+  const walk = (fields) => {
+    for (const node of Object.values(fields)) {
+      if (node.kind === "reference") deps.add(node.target);
+      else if (node.kind === "owned") {
+        if (node.mirror) deps.add(node.mirror);
+        if (node.shape) walk(node.shape);
+      }
+    }
+  };
+  walk(ir.fields);
+  return deps;
+}
+async function pushEntities(entities, options) {
+  const transport = options.fetch ?? ((req) => globalThis.fetch(req));
+  const base = options.url.replace(/\/$/, "");
+  const irs = Object.values(entities).map((e) => ({ name: e.name, ir: toIR(e) }));
+  const byName2 = new Map(irs.map((x) => [x.name, x]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (x) => {
+    if (seen.has(x.name)) return;
+    seen.add(x.name);
+    for (const dep of depsOf(x.ir)) {
+      const d = byName2.get(dep);
+      if (d) visit(d);
+    }
+    ordered.push(x);
+  };
+  for (const x of irs) visit(x);
+  const applied = [];
+  const review = [];
+  for (const { name, ir } of ordered) {
+    const renameMap = options.renames?.[name];
+    if (renameMap && Object.keys(renameMap).length > 0) {
+      const existing = await fetchIR(transport, base, options.key, name);
+      if (existing) {
+        const idByOldName = /* @__PURE__ */ new Map();
+        for (const [fname, fnode] of Object.entries(existing.fields)) if (fnode.id) idByOldName.set(fname, fnode.id);
+        for (const [oldName, newName] of Object.entries(renameMap)) {
+          const id = idByOldName.get(oldName);
+          const target = ir.fields[newName];
+          if (id && target) ir.fields = { ...ir.fields, [newName]: { ...target, id } };
+        }
+      }
+    }
+    const body = { ir };
+    if (options.confirm?.[name]) body.confirm = options.confirm[name];
+    if (options.fill?.[name]) body.fill = options.fill[name];
+    const res = await transport(
+      new Request(`${base}/admin/entities/${encodeURIComponent(name)}`, {
+        method: "PUT",
+        headers: { "x-api-key": options.key, "content-type": "application/json" },
+        body: JSON.stringify(body)
+      })
+    );
+    const json3 = await res.json().catch(() => null);
+    if (res.status === 200) applied.push(name);
+    else if (res.status === 409 && json3?.plan) review.push({ name, plan: json3.plan });
+    else throw errorFor(res.status, json3?.error ?? `Push failed for '${name}' (${res.status}).`);
+  }
+  return { applied, review };
+}
+
+// src/config.ts
+function defineConfig(config = {}) {
+  return config;
+}
+var DEFAULT_DIR = "weave";
+
+// src/scope.ts
+function defineScope(name, entities) {
+  return { name, entities };
+}
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function namePathToIds(entity, byName2, dotPath) {
+  const ids = [];
+  let fields = byName2.get(entity)?.fields ?? {};
+  const segs = dotPath.split(".");
+  for (let i = 0; i < segs.length; i++) {
+    const f = fields[segs[i]];
+    if (!f?.id) throw new Error(`scope: unknown field '${dotPath}' (em '${entity}').`);
+    ids.push(f.id);
+    if (i === segs.length - 1) break;
+    if (f.kind === "owned") fields = f.shape ?? {};
+    else if (f.kind === "reference") fields = byName2.get(f.target)?.fields ?? {};
+    else throw new Error(`scope: '${dotPath}' atravessa um escalar.`);
+  }
+  return ids;
+}
+function decodeOp(val) {
+  const ilikeUnwrap = (s) => {
+    if (typeof s === "string" && s.startsWith("%") && s.endsWith("%")) return { op: "contains", value: s.slice(1, -1) };
+    if (typeof s === "string" && s.endsWith("%")) return { op: "startsWith", value: s.slice(0, -1) };
+    return { op: "contains", value: s };
+  };
+  if ("ilike" in val) return ilikeUnwrap(val["ilike"]);
+  if ("eq" in val) return { op: "equals", value: val["eq"] };
+  if ("ne" in val) return { op: "notEquals", value: val["ne"] };
+  if ("gt" in val) return { op: "gt", value: val["gt"] };
+  if ("gte" in val) return { op: "gte", value: val["gte"] };
+  if ("lt" in val) return { op: "lt", value: val["lt"] };
+  if ("lte" in val) return { op: "lte", value: val["lte"] };
+  if ("in" in val) return { op: "in", value: val["in"] };
+  if ("notIn" in val) return { op: "notIn", value: val["notIn"] };
+  if ("isNull" in val) return { op: "isEmpty" };
+  return { op: "equals", value: void 0 };
+}
+function whereToFilter(where, entity, byName2) {
+  if (Array.isArray(where["and"])) {
+    return { and: where["and"].map((w) => whereToFilter(w, entity, byName2)) };
+  }
+  if (Array.isArray(where["or"])) {
+    return { or: where["or"].map((w) => whereToFilter(w, entity, byName2)) };
+  }
+  const idPath = [];
+  let cur = where;
+  let fields = byName2.get(entity)?.fields ?? {};
+  for (let guard = 0; guard < 16; guard++) {
+    const entry = Object.entries(cur)[0];
+    if (!entry) break;
+    const [key, val] = entry;
+    const f = fields[key];
+    if (!f?.id) throw new Error(`scope: campo '${key}' desconhecido em '${entity}'.`);
+    idPath.push(f.id);
+    if (f.kind === "column") {
+      const opObj = f.array && isObj(val) && "some" in val ? val["some"] : val;
+      const { op, value } = decodeOp(opObj);
+      return value === void 0 ? { path: idPath, op } : { path: idPath, op, value };
+    }
+    fields = f.kind === "owned" ? f.shape ?? {} : byName2.get(f.target)?.fields ?? {};
+    cur = isObj(val) && "some" in val ? val["some"] : val;
+  }
+  throw new Error(`scope: filtro inv\xE1lido em '${entity}'.`);
+}
+async function pushScopes(scopes, options) {
+  const transport = options.fetch ?? ((req) => globalThis.fetch(req));
+  const base = options.url.replace(/\/$/, "");
+  const listRes = await transport(
+    new Request(`${base}/admin/entities`, { method: "GET", headers: { "x-api-key": options.key } })
+  );
+  const listJson = await listRes.json().catch(() => null);
+  if (!listRes.ok || !listJson?.entities) {
+    throw errorFor(listRes.status, listJson?.error ?? "Failed to load entities for scope push.");
+  }
+  const byName2 = new Map(listJson.entities.map((e) => [e.name, e]));
+  const pushed = [];
+  for (const def of Object.values(scopes)) {
+    const entities = {};
+    for (const [entity, rule] of Object.entries(def.entities)) {
+      const rows = rule.where ? whereToFilter(rule.where, entity, byName2) : null;
+      let fields = null;
+      if (rule.fields?.include) {
+        fields = { mode: "include", paths: rule.fields.include.map((p) => namePathToIds(entity, byName2, p)) };
+      } else if (rule.fields?.exclude) {
+        fields = { mode: "exclude", paths: rule.fields.exclude.map((p) => namePathToIds(entity, byName2, p)) };
+      }
+      entities[entity] = { verbs: rule.verbs, rows, fields };
+    }
+    const res = await transport(
+      new Request(`${base}/admin/scopes/${encodeURIComponent(def.name)}`, {
+        method: "PUT",
+        headers: { "x-api-key": options.key, "content-type": "application/json" },
+        body: JSON.stringify({ name: def.name, entities })
+      })
+    );
+    if (!res.ok) {
+      const j = await res.json().catch(() => null);
+      throw errorFor(res.status, j?.error ?? `Push scope '${def.name}' failed (${res.status}).`);
+    }
+    pushed.push(def.name);
+  }
+  return { pushed };
+}
+
+// src/gen.ts
+function baseExpr(node, ctx, self) {
+  if (node.kind === "column") {
+    ctx.builders.add(node.type);
+    if (node.array) {
+      ctx.builders.add("array");
+      let s2 = `array(${node.type}())`;
+      if (node.notNull === false) s2 += ".nullable()";
+      if (node.unique) s2 += ".unique()";
+      if (node.index) s2 += ".index()";
+      return s2;
+    }
+    let s = `${node.type}()`;
+    if (node.notNull) s += ".notNull()";
+    if (node.unique) s += ".unique()";
+    if (node.index) s += ".index()";
+    if (node.default !== void 0) s += `.default(${JSON.stringify(node.default)})`;
+    return s;
+  }
+  if (node.kind === "reference") {
+    ctx.builders.add("reference");
+    if (node.target !== self) ctx.imports.add(node.target);
+    if (node.cardinality === "many") {
+      ctx.builders.add("array");
+      return `reference(array(${node.target}))`;
+    }
+    return `reference(${node.target})${node.notNull ? ".notNull()" : ""}`;
+  }
+  if (node.mirror) ctx.mirror = true;
+  ctx.builders.add("owned");
+  const inner = shapeSource(node.shape ?? {}, ctx, self);
+  return node.array ? `owned(array({ ${inner} }))` : `owned({ ${inner} })`;
+}
+function fieldSource(node, ctx, self) {
+  const base = baseExpr(node, ctx, self);
+  const id = ctx.withId && node.id ? `.$id(${JSON.stringify(node.id)})` : "";
+  return base + id;
+}
+function shapeSource(fields, ctx, self) {
+  return Object.entries(fields).map(([k, n]) => `${k}: ${fieldSource(n, ctx, self)}`).join(", ");
+}
+function irToSource(ir, options = {}) {
+  const ctx = { builders: /* @__PURE__ */ new Set(), imports: /* @__PURE__ */ new Set(), mirror: false, withId: options.withId ?? false };
+  const body = Object.entries(ir.fields).map(([k, n]) => `  ${k}: ${fieldSource(n, ctx, ir.name)},`).join("\n");
+  const builders = ["defineEntity", ...[...ctx.builders].sort()];
+  const lines = [`import { ${builders.join(", ")} } from "@mauroandre/weave-sdk";`];
+  for (const t of [...ctx.imports].sort()) lines.push(`import ${t} from "./${t}.js";`);
+  if (ctx.mirror) lines.push(`// \u26A0 esta entidade usa mirror \u2014 gere/edite a forma \xE0 m\xE3o (o builder n\xE3o tem mirror()).`);
+  lines.push("", `export default defineEntity(${JSON.stringify(ir.name)}, {`, body, "});", "");
+  return lines.join("\n");
+}
+function idPathToNames(entity, byName2, idPath) {
+  const names = [];
+  let fields = byName2.get(entity)?.fields ?? {};
+  for (let i = 0; i < idPath.length; i++) {
+    const entry = Object.entries(fields).find(([, f2]) => f2.id === idPath[i]);
+    if (!entry) throw new Error(`scope gen: field id '${idPath[i]}' n\xE3o encontrado em '${entity}'.`);
+    const [name, f] = entry;
+    names.push(name);
+    if (i === idPath.length - 1) break;
+    if (f.kind === "owned") fields = f.shape ?? {};
+    else if (f.kind === "reference") fields = byName2.get(f.target)?.fields ?? {};
+    else throw new Error(`scope gen: caminho atravessa um escalar em '${entity}'.`);
+  }
+  return names;
+}
+function opToWhere(op, value) {
+  const str = typeof value === "string";
+  switch (op) {
+    case "contains":
+      return { ilike: str ? `%${value}%` : value };
+    case "startsWith":
+      return { ilike: str ? `${value}%` : value };
+    case "equals":
+    case "on":
+      return { eq: value };
+    case "notEquals":
+      return { ne: value };
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return { [op]: value };
+    case "before":
+      return { lt: value };
+    case "after":
+      return { gt: value };
+    case "in":
+      return { in: value };
+    case "notIn":
+      return { notIn: value };
+    case "isTrue":
+      return { eq: true };
+    case "isFalse":
+      return { eq: false };
+    case "isEmpty":
+      return { isNull: true };
+    default:
+      return { eq: value };
+  }
+}
+function buildWhere(entity, byName2, names, op, value) {
+  const rec = (fields, idx) => {
+    const seg = names[idx];
+    const f = fields[seg];
+    if (idx === names.length - 1) {
+      const sc = opToWhere(op, value);
+      const isArray = f?.kind === "column" && f.array === true;
+      return { [seg]: isArray && op !== "isEmpty" ? { some: sc } : sc };
+    }
+    let next = {};
+    let toMany = false;
+    if (f?.kind === "owned") {
+      next = f.shape ?? {};
+      toMany = f.array === true;
+    } else if (f?.kind === "reference") {
+      next = byName2.get(f.target)?.fields ?? {};
+      toMany = f.cardinality === "many";
+    }
+    const inner = rec(next, idx + 1);
+    return { [seg]: toMany ? { some: inner } : inner };
+  };
+  return rec(byName2.get(entity)?.fields ?? {}, 0);
+}
+function filterToWhere(filter, entity, byName2) {
+  if ("and" in filter) return { and: filter.and.map((f) => filterToWhere(f, entity, byName2)) };
+  if ("or" in filter) return { or: filter.or.map((f) => filterToWhere(f, entity, byName2)) };
+  const names = idPathToNames(entity, byName2, filter.path);
+  return buildWhere(entity, byName2, names, filter.op, filter.value);
+}
+var IDENT = /^[A-Za-z_$][\w$]*$/;
+function lit(value, indent = 0) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.map((v) => lit(v, indent)).join(", ")}]`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const pad = "  ".repeat(indent + 1);
+    const close = "  ".repeat(indent);
+    const body = entries.map(([k, v]) => `${pad}${IDENT.test(k) ? k : JSON.stringify(k)}: ${lit(v, indent + 1)}`).join(",\n");
+    return `{
+${body},
+${close}}`;
+  }
+  return JSON.stringify(value);
+}
+function scopeToSource(scope, byName2) {
+  const rules = {};
+  for (const [entity, rule] of Object.entries(scope.entities)) {
+    const out = { verbs: rule.verbs };
+    if (rule.rows) out["where"] = filterToWhere(rule.rows, entity, byName2);
+    if (rule.fields) {
+      const paths = rule.fields.paths.map((p) => idPathToNames(entity, byName2, p).join("."));
+      out["fields"] = rule.fields.mode === "include" ? { include: paths } : { exclude: paths };
+    }
+    rules[entity] = out;
+  }
+  return [
+    `import { defineScope } from "@mauroandre/weave-sdk";`,
+    "",
+    `export default defineScope(${JSON.stringify(scope.name)}, ${lit(rules)});`,
+    ""
+  ].join("\n");
+}
+function barrelSource(names) {
+  return [
+    `// GERADO por \`weave gen\` \u2014 n\xE3o edite \xE0 m\xE3o.`,
+    ...names.map((n) => `export { default as ${n} } from "./${n}.js";`),
+    ""
+  ].join("\n");
+}
+function clientSource() {
+  return [
+    `// GERADO por \`weave gen\` \u2014 n\xE3o edite \xE0 m\xE3o. Uso server-side (a key \xE9 segredo).`,
+    `import { createClient } from "@mauroandre/weave-sdk";`,
+    `import * as entities from "./entities/index.js";`,
+    "",
+    `export const weave = createClient({`,
+    `  url: process.env.WEAVE_URL!,`,
+    `  key: process.env.WEAVE_KEY!,`,
+    `  entities,`,
+    `});`,
+    ""
+  ].join("\n");
+}
+async function fetchJson(transport, url, key, what) {
+  const res = await transport(new Request(url, { method: "GET", headers: { "x-api-key": key } }));
+  const json3 = await res.json().catch(() => null);
+  if (!res.ok || !json3) throw errorFor(res.status, json3?.error ?? `Failed to load ${what}.`);
+  return json3;
+}
+async function genProject(options) {
+  const transport = options.fetch ?? ((req) => globalThis.fetch(req));
+  const base = options.url.replace(/\/$/, "");
+  const ents = await fetchJson(transport, `${base}/admin/entities`, options.key, "entities");
+  const scps = await fetchJson(transport, `${base}/admin/scopes`, options.key, "scopes");
+  const byName2 = new Map(ents.entities.map((e) => [e.name, e]));
+  const files = {};
+  const entityNames = [];
+  for (const ir of ents.entities) {
+    files[`entities/${ir.name}.ts`] = irToSource(ir, { withId: true });
+    entityNames.push(ir.name);
+  }
+  entityNames.sort();
+  files["entities/index.ts"] = barrelSource(entityNames);
+  const scopeNames = [];
+  for (const s of scps.scopes) {
+    try {
+      files[`scopes/${s.name}.ts`] = scopeToSource(s, byName2);
+      scopeNames.push(s.name);
+    } catch {
+    }
+  }
+  scopeNames.sort();
+  files["scopes/index.ts"] = barrelSource(scopeNames);
+  files["index.ts"] = clientSource();
+  return { files, entities: entityNames, scopes: scopeNames };
+}
+async function pullEntities(options) {
+  const transport = options.fetch ?? ((req) => globalThis.fetch(req));
+  const base = options.url.replace(/\/$/, "");
+  const json3 = await fetchJson(transport, `${base}/admin/entities`, options.key, "entities");
+  const files = {};
+  const names = [];
+  for (const ir of json3.entities) {
+    files[`${ir.name}.ts`] = irToSource(ir);
+    names.push(ir.name);
+  }
+  return { files, names: names.sort() };
+}
+
+export {
+  Column,
+  Owned,
+  owned,
+  Reference,
+  reference,
+  int22 as int2,
+  int42 as int4,
+  int82 as int8,
+  numeric2 as numeric,
+  float42 as float4,
+  float82 as float8,
+  text2 as text,
+  varchar2 as varchar,
+  bpchar2 as bpchar,
+  timestamptz2 as timestamptz,
+  timestamp2 as timestamp,
+  date2 as date,
+  time2 as time,
+  interval2 as interval,
+  bool2 as bool,
+  uuid2 as uuid,
+  json2 as json,
+  jsonb2 as jsonb,
+  bytea2 as bytea,
+  array,
+  defineEntity,
+  WeaveError,
+  WeaveAuthError,
+  WeaveScopeError,
+  WeaveNotFoundError,
+  WeaveValidationError,
+  errorFor,
+  pushEntities,
+  defineConfig,
+  DEFAULT_DIR,
+  defineScope,
+  pushScopes,
+  irToSource,
+  scopeToSource,
+  genProject,
+  pullEntities
+};
+//# sourceMappingURL=chunk-PWTED7ZO.js.map