@xano/sdk 1.0.0

package/dist/chunk-JGE7CAWB.js

@@ -0,0 +1,148 @@
+import {
+  sdkKindName
+} from "./chunk-6MR5TI5V.js";
+
+// src/validate/capabilities.ts
+var CAPABILITIES = {
+  cache: {
+    label: "Redis / cache support",
+    effect: "every `s.redis.*` statement, including `s.redis.ratelimit`"
+  },
+  lambda: {
+    label: "Lambda (JavaScript/TypeScript) support",
+    effect: "`s.lambda`, and the `fl.lambda`-family filters that run through it"
+  },
+  premiumInstance: {
+    label: "a premium instance",
+    effect: "`s.await` (awaiting an async function run) and direct SQL"
+  },
+  directQuery: {
+    label: "direct-query support",
+    effect: "`s.db.direct_query` \u2014 raw SQL against this workspace's own tables"
+  },
+  microservice: {
+    label: "microservice support",
+    effect: "`s.microservice.request`"
+  },
+  realtimeV2: {
+    label: "realtime (v2) support",
+    effect: "`s.realtime.publish`"
+  },
+  rawFileAccess: {
+    label: "raw file access",
+    effect: "reading a file resource's bytes, and the CSV/JSONL streaming readers"
+  },
+  paidInstance: {
+    label: "a paid (non-free) instance",
+    effect: "the whole `s.zip.*` family"
+  },
+  fileUpload: {
+    label: "file upload",
+    effect: "creating and deleting stored file resources"
+  },
+  images: { label: "image storage", effect: "`s.storage.create_image`" },
+  videos: { label: "video storage", effect: "`s.storage.create_video`" },
+  audio: { label: "audio storage", effect: "`s.storage.create_audio`" },
+  attachment: { label: "attachment storage", effect: "`s.storage.create_attachment`" },
+  privateStorage: {
+    label: "private file storage",
+    effect: "`s.storage.sign_private_url`"
+  },
+  webflow: { label: "the Webflow integration", effect: "`s.webflow.request`" },
+  datadog: { label: "the Datadog integration", effect: "every `s.datadog.*` statement" }
+};
+var STATEMENT_CAPABILITIES = {
+  // Redis / cache.
+  "mvp:redis_countlist": ["cache"],
+  "mvp:redis_decr": ["cache"],
+  "mvp:redis_del": ["cache"],
+  "mvp:redis_get": ["cache"],
+  "mvp:redis_has": ["cache"],
+  "mvp:redis_incr": ["cache"],
+  "mvp:redis_keys": ["cache"],
+  "mvp:redis_poplist": ["cache"],
+  "mvp:redis_pushlist": ["cache"],
+  "mvp:redis_rangelist": ["cache"],
+  "mvp:redis_ratelimit": ["cache"],
+  "mvp:redis_remove_list": ["cache"],
+  "mvp:redis_set": ["cache"],
+  "mvp:redis_shiftlist": ["cache"],
+  "mvp:redis_unshiftlist": ["cache"],
+  // Compute and data.
+  "mvp:lambda": ["lambda"],
+  "mvp:async_function_await": ["premiumInstance"],
+  "mvp:dbo_direct_query": ["premiumInstance", "directQuery"],
+  "mvp:microservice_request": ["microservice"],
+  "mvp:realtime_publish": ["realtimeV2"],
+  // Files. The zip family is gated on the instance not being FREE; the readers
+  // below are gated on raw file access, which is a separate flag.
+  "mvp:zip_add_file_resource": ["paidInstance"],
+  "mvp:zip_create_file_resource": ["paidInstance"],
+  "mvp:zip_delete_file_resource": ["paidInstance"],
+  "mvp:zip_extract_file_resource": ["paidInstance"],
+  "mvp:zip_view_contents": ["paidInstance"],
+  "mvp:create_var_from_file_resource": ["rawFileAccess"],
+  "mvp:csv_stream": ["rawFileAccess"],
+  "mvp:jsonl_stream": ["rawFileAccess"],
+  "mvp:create_file_resource": ["fileUpload"],
+  "mvp:delete_file": ["fileUpload"],
+  "mvp:create_image": ["images"],
+  "mvp:create_video": ["videos"],
+  "mvp:create_audio": ["audio"],
+  "mvp:create_attachment": ["attachment"],
+  "mvp:vault_sign_url": ["privateStorage"],
+  // Integrations. The external-cloud storage statements (S3/GCS/Azure) are
+  // deliberately absent: the editor gates none of them, and claiming otherwise
+  // would send someone checking a plan for something that is always available.
+  "mvp:connect_webflow_api_request": ["webflow"],
+  "mvp:datadog_log": ["datadog"],
+  "mvp:datadog_log_bulk": ["datadog"],
+  "mvp:datadog_metric": ["datadog"],
+  "mvp:datadog_metric_bulk": ["datadog"]
+};
+var STATEMENT_EFFECTS = {
+  "mvp:async_function_await": "`s.await` (awaiting an async function run)",
+  "mvp:dbo_direct_query": "direct SQL"
+};
+function effectOf(id, names) {
+  const parts = [...names].sort().map((n) => Object.hasOwn(STATEMENT_EFFECTS, n) ? STATEMENT_EFFECTS[n] : void 0);
+  return parts.every((p) => p !== void 0) && parts.length > 0 && id === "premiumInstance" ? parts.join(" and ") : CAPABILITIES[id].effect;
+}
+function bundleCapabilities(bundle) {
+  const statements = /* @__PURE__ */ new Map();
+  const objects = /* @__PURE__ */ new Map();
+  const walk = (node, context, key, section) => {
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, context, key, section);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const obj = node;
+    const name = obj.name;
+    const own = typeof name === "string" && name !== "" && !name.includes(":") ? typeof obj.verb === "string" && obj.verb !== "" ? `${obj.verb} ${name}` : name : void 0;
+    const nextContext = own === void 0 ? context : section && key !== void 0 ? `${sdkKindName(key, obj)} "${own}"` : own;
+    if (typeof name === "string") {
+      const ids = Object.hasOwn(STATEMENT_CAPABILITIES, name) ? STATEMENT_CAPABILITIES[name] : void 0;
+      for (const id of ids ?? []) {
+        (statements.get(id) ?? statements.set(id, /* @__PURE__ */ new Set()).get(id)).add(name);
+        if (context !== "") (objects.get(id) ?? objects.set(id, /* @__PURE__ */ new Set()).get(id)).add(context);
+      }
+    }
+    for (const [k, value] of Object.entries(obj)) walk(value, nextContext, k, key === "payload");
+  };
+  walk(bundle, "");
+  return [...statements.entries()].map(([id, names]) => ({
+    id,
+    label: CAPABILITIES[id].label,
+    effect: effectOf(id, names),
+    statements: [...names].sort(),
+    objects: [...objects.get(id) ?? []].sort()
+  })).sort((a, b) => a.label.localeCompare(b.label));
+}
+
+export {
+  CAPABILITIES,
+  STATEMENT_CAPABILITIES,
+  bundleCapabilities
+};
+//# sourceMappingURL=chunk-JGE7CAWB.js.map

package/dist/chunk-JTUKLCXS.js

@@ -0,0 +1,92 @@
+import {
+  assertWritable,
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+
+// src/emit/project-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var SDK_PACKAGE = "@xano/sdk";
+function readProjectManifest(projectDir) {
+  const path = join(projectDir, "package.json");
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function declaredDependencies(manifest) {
+  const names = /* @__PURE__ */ new Set();
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = manifest[field];
+    if (typeof deps === "object" && deps !== null && !Array.isArray(deps)) {
+      for (const name of Object.keys(deps))
+        names.add(name);
+    }
+  }
+  return [...names];
+}
+function configuredPackages(projectDir, parsed) {
+  const manifest = parsed !== void 0 ? parsed : readProjectManifest(projectDir);
+  if (manifest === null) return [];
+  const block = manifest["xanosdk"];
+  if (typeof block !== "object" || block === null || Array.isArray(block))
+    return [];
+  return Object.keys(block).filter(
+    (pkg) => pkg !== SDK_PACKAGE
+  );
+}
+function readToolchainConfig(projectDir, pkg, parsed) {
+  const manifest = parsed !== void 0 ? parsed : readProjectManifest(projectDir);
+  if (manifest === null) return null;
+  const block = manifest["xanosdk"];
+  if (typeof block !== "object" || block === null || Array.isArray(block))
+    return null;
+  const own = block[pkg];
+  if (typeof own !== "object" || own === null || Array.isArray(own))
+    return null;
+  return own;
+}
+function readToolchainBlock(projectDir, parsed) {
+  const manifest = parsed !== void 0 ? parsed : readProjectManifest(projectDir);
+  if (manifest === null) return {};
+  const block = manifest["xanosdk"];
+  if (typeof block !== "object" || block === null || Array.isArray(block))
+    return {};
+  return block;
+}
+function composeToolchainConfig(raw, block) {
+  const manifest = JSON.parse(raw);
+  if (Object.keys(block).length === 0) delete manifest["xanosdk"];
+  else manifest["xanosdk"] = block;
+  const trailing = /(?:\r?\n)*$/.exec(raw)?.[0] ?? "";
+  const next = JSON.stringify(manifest, null, detectIndent(raw)) + (trailing === "" ? "" : trailing);
+  return raw.includes("\r\n") ? next.replace(/\r?\n/g, "\r\n") : next;
+}
+function detectIndent(raw) {
+  const match = /\{[^\n]*\r?\n([ \t]+)"/.exec(raw);
+  return match?.[1] ?? 2;
+}
+function writeToolchainConfig(projectDir, block) {
+  const path = join(projectDir, "package.json");
+  const raw = readFileSync(path, "utf8");
+  const next = composeToolchainConfig(raw, block);
+  if (next === raw) return false;
+  assertWritable(path);
+  atomicWrite(path, next);
+  return true;
+}
+
+export {
+  SDK_PACKAGE,
+  readProjectManifest,
+  declaredDependencies,
+  configuredPackages,
+  readToolchainConfig,
+  readToolchainBlock,
+  composeToolchainConfig,
+  writeToolchainConfig
+};
+//# sourceMappingURL=chunk-JTUKLCXS.js.map

package/dist/chunk-JZGVVJSI.js

@@ -0,0 +1,66 @@
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  UsageError,
+  displayPath
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/writable.ts
+import { accessSync, constants, existsSync, statSync } from "fs";
+import { dirname, resolve } from "path";
+function unwritableBlocker(file) {
+  const target = resolve(file);
+  if (existsSync(target) && !statSync(target).isDirectory() && !canWrite(target)) return target;
+  let dir = dirname(target);
+  while (!existsSync(dir)) {
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+  return canWrite(dir) ? void 0 : dir;
+}
+function canWrite(path) {
+  return canAccess(path, constants.W_OK);
+}
+function canAccess(path, mode) {
+  try {
+    accessSync(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isUnwritableError(err) {
+  const code = err?.code;
+  return code === "EACCES" || code === "EPERM" || code === "EROFS";
+}
+function unwritableError(file, alternative) {
+  const blocker = unwritableBlocker(file) ?? dirname(resolve(file));
+  const what = blocker === resolve(file) ? "is read-only" : `is in ${displayPath(blocker)}/, which is not writable`;
+  return new UsageError(
+    `Cannot write ${displayPath(resolve(file))}: it ${what}. Make it writable (\`chmod u+w ${shellWord(displayPath(blocker))}\`)${alternative === void 0 ? "" : `, or ${alternative}`}.`
+  );
+}
+function assertWritable(file, alternative) {
+  if (unwritableBlocker(file) !== void 0) throw unwritableError(file, alternative);
+}
+function unreadableError(file) {
+  const shown = displayPath(resolve(file));
+  return new UsageError(`Cannot read ${shown}: permission denied. Make it readable and writable (\`chmod u+rw ${shellWord(shown)}\`).`);
+}
+function assertReadWritable(file, alternative) {
+  const target = resolve(file);
+  if (existsSync(target) && !statSync(target).isDirectory() && !canAccess(target, constants.R_OK)) throw unreadableError(file);
+  assertWritable(file, alternative);
+}
+
+export {
+  unwritableBlocker,
+  isUnwritableError,
+  unwritableError,
+  assertWritable,
+  unreadableError,
+  assertReadWritable
+};
+//# sourceMappingURL=chunk-JZGVVJSI.js.map