@xano/sdk 1.0.0

package/dist/chunk-U64O2MXY.js

@@ -0,0 +1,407 @@
+import {
+  repoBoundaryFrom
+} from "./chunk-ROY4YAEQ.js";
+import {
+  LocalFileNotFoundError
+} from "./chunk-PTHVMXZI.js";
+import {
+  buildContentEnvelope
+} from "./chunk-LQCMKAJ7.js";
+import {
+  SEED_FILE,
+  assertSeedIds,
+  assertSeedUnique,
+  coerceSeedRowValues,
+  isNonPublicColumn,
+  isSeedFileSource,
+  seedFailure,
+  tableColumns,
+  tableIndexes
+} from "./chunk-HVRUQXGD.js";
+import {
+  DiagnosticError
+} from "./chunk-2EZ3ZJZZ.js";
+import {
+  HOSTED_FILE,
+  HOSTED_FILE_SCHEME,
+  HOSTED_ROW_PATH_PREFIX,
+  isHostedFile
+} from "./chunk-XNCP4KYO.js";
+import {
+  resolveRef
+} from "./chunk-NZOWWHU5.js";
+
+// src/workspace/seed.ts
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/util/local-file.ts
+function isMissingFile(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+
+// src/workspace/seed.ts
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
+
+// src/workspace/hosted-file.ts
+import { createHash } from "crypto";
+import { lstatSync, readFileSync, realpathSync } from "fs";
+import { basename, dirname, extname, isAbsolute, relative } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+var HOSTED_FILE_MAX_BYTES = 10 * 1024 * 1024;
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".csv": "text/csv"
+};
+var IMAGE_SIGNATURES = {
+  "image/png": (b) => b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])),
+  "image/jpeg": (b) => b[0] === 255 && b[1] === 216 && b[2] === 255,
+  "image/webp": (b) => b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP",
+  "image/gif": (b) => b.subarray(0, 6).toString("latin1") === "GIF87a" || b.subarray(0, 6).toString("latin1") === "GIF89a",
+  "image/x-icon": (b) => b[0] === 0 && b[1] === 0 && b[2] === 1 && b[3] === 0
+};
+function assertInsideRepo(where, file, base) {
+  if (!base.startsWith("file:")) return;
+  const boundary = repoBoundaryFrom(dirname(fileURLToPath(base)));
+  const root = realpathSync(boundary.root);
+  const real = realpathSync(file);
+  const rel = relative(root, real);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    const via = lstatSync(file).isSymbolicLink() ? ` (a link to "${real}")` : "";
+    throw new Error(
+      `${where}: "${file}"${via} is outside the ${boundary.kind} (${root}). A hosted file ships only from inside it \u2014 copy the file into ${root} and point at the copy.`
+    );
+  }
+}
+function resolveHostedFile(ref, rules = {}) {
+  const { path, base, access } = ref[HOSTED_FILE];
+  const where = `${rules.field ? `${rules.field}: ` : ""}hostedFile("${path}")`;
+  const baseUrl = /^[a-z][a-z0-9+.-]*:/i.test(base) ? base : pathToFileURL(base).href;
+  const file = fileURLToPath(new URL(path, baseUrl));
+  let bytes;
+  try {
+    bytes = readFileSync(file);
+  } catch (cause) {
+    const relative2 = "The path is resolved relative to the module that declares it (the `import.meta.url` you passed as `base`).";
+    if (isMissingFile(cause)) throw new LocalFileNotFoundError(`${where}: no file at "${file}". ${relative2}`);
+    throw new Error(`${where}: cannot read "${file}". ${relative2}`, { cause });
+  }
+  assertInsideRepo(where, file, baseUrl);
+  if (bytes.length === 0) throw new Error(`${where}: "${file}" is empty.`);
+  if (bytes.length > HOSTED_FILE_MAX_BYTES) {
+    throw new Error(`${where}: "${file}" is ${bytes.length} bytes, over the ${HOSTED_FILE_MAX_BYTES}-byte limit for a hosted file.`);
+  }
+  const mime = MIME_BY_EXT[extname(file).toLowerCase()] ?? "application/octet-stream";
+  const signature = IMAGE_SIGNATURES[mime];
+  if (signature !== void 0 && !signature(bytes)) {
+    throw new Error(`${where}: "${file}" is named as ${mime}, but its contents are not a ${mime.slice(6).toUpperCase()} image.`);
+  }
+  if (rules.declaredMime !== void 0 && rules.declaredMime !== mime) {
+    throw new Error(`${where}: \`mimeType\` says ${rules.declaredMime}, but "${file}" is ${mime}. Drop \`mimeType\` or make it ${mime}.`);
+  }
+  if (rules.allowedMimes && !rules.allowedMimes.includes(mime)) {
+    throw new Error(`${where}: "${file}" is ${mime}, but this field accepts ${rules.allowedMimes.join(", ")}.`);
+  }
+  if (rules.mimeKind && !mime.startsWith(`${rules.mimeKind}/`)) {
+    throw new Error(`${where}: "${file}" is ${mime}, but this field holds ${rules.mimeKind}/* files.`);
+  }
+  if (rules.requirePublic && access !== "public") {
+    throw new Error(`${where}: a private file cannot be used here \u2014 this field is fetched with no credentials, so the file must be public.`);
+  }
+  const canonical = createHash("sha256").update(bytes).digest("hex").slice(0, 32);
+  const name = basename(file);
+  if (Buffer.byteLength(`vault/${canonical}/${name}`) > 100) {
+    throw new Error(`${where}: the file name "${name}" is too long to ship \u2014 keep it under ${100 - `vault/${canonical}/`.length} bytes.`);
+  }
+  return {
+    name,
+    bytes,
+    size: bytes.length,
+    mime,
+    access,
+    canonical,
+    sig: createHash("sha1").update(bytes).digest("hex")
+  };
+}
+function hostedFileResolver() {
+  const byCanonical = /* @__PURE__ */ new Map();
+  const resolveFile = (ref, rules) => {
+    const file = resolveHostedFile(ref, rules);
+    const seen = byCanonical.get(file.canonical);
+    if (seen !== void 0 && seen.access !== file.access) {
+      throw new Error(
+        `${rules.field ? `${rules.field}: ` : ""}hostedFile("${ref[HOSTED_FILE].path}") is ${file.access}, but the same file is already used as ${seen.access} (as "${seen.name}"). One file cannot be both \u2014 give the ${file.access === "private" ? "private" : "public"} use its own copy.`
+      );
+    }
+    if (seen !== void 0) return seen;
+    byCanonical.set(file.canonical, file);
+    return file;
+  };
+  return {
+    resolve: (ref, rules) => hostedFilePlaceholder(resolveFile(ref, rules)),
+    resolveFile,
+    files: () => [...byCanonical.values()],
+    libraryRows: () => [...byCanonical.values()].map(hostedFileLibraryRow)
+  };
+}
+function hostedFilePlaceholder(file) {
+  return `${HOSTED_FILE_SCHEME}${file.canonical}/${encodeURIComponent(file.name)}`;
+}
+function libraryType(mime) {
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/")) return "audio";
+  return "attachment";
+}
+function hostedFileColumnValue(file) {
+  return {
+    access: file.access,
+    path: `${HOSTED_ROW_PATH_PREFIX}${file.canonical}/_/${encodeURIComponent(file.name)}`,
+    name: file.name,
+    type: libraryType(file.mime),
+    size: file.size,
+    mime: file.mime,
+    meta: {}
+  };
+}
+function hostedFileLibraryRow(file) {
+  return {
+    name: file.name,
+    size: file.size,
+    type: libraryType(file.mime),
+    mime: file.mime,
+    canonical: file.canonical,
+    // The row's identity on import is its guid, so the content identity doubles
+    // as it: re-importing the same file updates its row instead of adding one.
+    guid: file.canonical,
+    sig: file.sig,
+    access: file.access,
+    meta: {}
+  };
+}
+function hostedFileArchivePath(file) {
+  return `vault/${file.canonical}/${file.name}`;
+}
+
+// src/workspace/seed.ts
+var SEED_PAGE_TARGET_BYTES = 512 * 1024;
+async function resolveSeedRows(source) {
+  if (isSeedFileSource(source)) return readSeedFile(source[SEED_FILE]);
+  const resolved = typeof source === "function" ? await source() : source;
+  const rows = Array.isArray(resolved) ? resolved : unwrapDefaultExport(resolved);
+  if (!Array.isArray(rows)) {
+    throw new Error(`seed source did not resolve to an array of rows (got ${typeof resolved}).`);
+  }
+  return rows;
+}
+function readSeedFile(ref) {
+  const where = `seedFile("${ref.path}")`;
+  const base = /^[a-z][a-z0-9+.-]*:/i.test(ref.base) ? ref.base : pathToFileURL2(ref.base).href;
+  const file = fileURLToPath2(new URL(ref.path, base));
+  let text;
+  try {
+    text = readFileSync2(file, "utf8");
+  } catch (cause) {
+    const relative2 = `The path is resolved relative to the module that declares the table (the \`import.meta.url\` you passed as \`base\`).`;
+    if (isMissingFile(cause)) throw new LocalFileNotFoundError(`${where}: no file at "${file}". ${relative2}`);
+    throw new Error(`${where}: cannot read "${file}". ${relative2}`, { cause });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (cause) {
+    throw new Error(`${where}: "${file}" is not valid JSON \u2014 ${cause.message}`, {
+      cause
+    });
+  }
+  const lossy = lossyJsonInteger(text);
+  if (lossy !== void 0) {
+    throw new Error(
+      `${where}: "${file}" holds the number ${lossy}, which JSON parsing reads as ${BigInt(Number(lossy))} \u2014 past \xB19007199254740991 a JSON number loses its low digits. Quote it ("${lossy}") so it is seeded exactly.`
+    );
+  }
+  const rows = Array.isArray(parsed) ? parsed : unwrapDefaultExport(parsed);
+  if (!Array.isArray(rows)) {
+    throw new Error(
+      `${where}: "${file}" must hold an array of seed rows (got ${typeof parsed}).`
+    );
+  }
+  return rows;
+}
+function lossyJsonInteger(text) {
+  for (const [token] of text.matchAll(/"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g)) {
+    if (!/^-?\d{16,}$/.test(token)) continue;
+    if (BigInt(Number(token)) !== BigInt(token)) return token;
+  }
+  return void 0;
+}
+function unwrapDefaultExport(value) {
+  if (value === null || typeof value !== "object") return value;
+  const fallback = value.default;
+  return Array.isArray(fallback) ? fallback : value;
+}
+function coerceSeedRows(tableName, columns, rows, opts = {}) {
+  const coerced = coerceSeedRowValues(tableName, columns, rows, opts);
+  assignPrimaryKeys(tableName, columns, coerced);
+  return coerced;
+}
+function assignPrimaryKeys(tableName, columns, rows) {
+  if (!assertSeedIds(tableName, columns, rows)) return;
+  const idType = columns.find((c) => c.name === "id")?.type;
+  rows.forEach((r, i) => {
+    r.id = idType === "int" ? i + 1 : seedUuid(tableName, i);
+  });
+}
+function seedUuid(tableName, index) {
+  const h = createHash2("sha256").update(`xanosdk:seed-id:${tableName}:${index}`).digest("hex");
+  const version5 = `5${h.slice(13, 16)}`;
+  const variant = (parseInt(h.slice(16, 17), 16) & 3 | 8).toString(16) + h.slice(17, 20);
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${version5}-${variant}-${h.slice(20, 32)}`;
+}
+function paginateRows(rows, budgetBytes = SEED_PAGE_TARGET_BYTES) {
+  const pages = [];
+  let page = [];
+  let size = 0;
+  for (const row of rows) {
+    const rowBytes = Buffer.byteLength(JSON.stringify(row), "utf8");
+    if (page.length > 0 && size + rowBytes > budgetBytes) {
+      pages.push(page);
+      page = [];
+      size = 0;
+    }
+    page.push(row);
+    size += rowBytes;
+  }
+  if (page.length > 0) pages.push(page);
+  return pages;
+}
+async function buildSeedContentFiles(tableDefs, hostedFiles = hostedFileResolver(), workspaceUseXdo = false) {
+  const files = [];
+  const problems = [];
+  for (const def of tableDefs) {
+    if (def.seed === void 0) continue;
+    const rows = await resolveSeedRows(def.seed);
+    if (rows.length === 0) continue;
+    let coerced;
+    try {
+      coerced = coerceSeedRows(def.name, tableColumns(def), rows, { useXdo: def.useXdo ?? workspaceUseXdo });
+      assertSeedUnique(def.name, tableIndexes(def), coerced);
+      resolveSeedFiles(def.name, tableColumns(def), coerced, hostedFiles);
+    } catch (err) {
+      if (err instanceof DiagnosticError) problems.push(...err.details);
+      else problems.push({ severity: "error", code: "seed.invalid", message: err.message });
+      continue;
+    }
+    const guid = resolveRef("dbo", def);
+    const pages = paginateRows(coerced);
+    pages.forEach((page, i) => {
+      files.push({ name: contentFileName(guid, i + 1), content: JSON.stringify(buildContentEnvelope(page)) });
+    });
+  }
+  if (problems.length > 0) throw seedFailure(problems);
+  return files;
+}
+async function registerSeedHostedFiles(tableDefs, hostedFiles, workspaceUseXdo = false) {
+  for (const def of tableDefs) {
+    if (def.seed === void 0) continue;
+    try {
+      const columns = tableColumns(def);
+      resolveSeedFiles(def.name, columns, coerceSeedRows(def.name, columns, await resolveSeedRows(def.seed), { useXdo: def.useXdo ?? workspaceUseXdo }), hostedFiles);
+    } catch {
+    }
+  }
+}
+var FILE_COLUMN_KIND = {
+  blob_img: "image",
+  blob_video: "video",
+  blob_audio: "audio"
+};
+function resolveSeedFiles(table, columns, rows, hostedFiles) {
+  const fileColumns = columns.filter((c) => c.type.startsWith("blob"));
+  if (fileColumns.length === 0) return;
+  rows.forEach((row, i) => {
+    for (const col of fileColumns) {
+      const rules = { field: `table "${table}" seed row ${i}, column "${col.name}"`, mimeKind: FILE_COLUMN_KIND[col.type] };
+      const value = row[col.name];
+      const one = (v) => isHostedFile(v) ? hostedFileColumnValue(hostedFiles.resolveFile(v, rules)) : v;
+      if (isHostedFile(value)) row[col.name] = one(value);
+      else if (Array.isArray(value) && value.some(isHostedFile)) row[col.name] = value.map(one);
+    }
+  });
+}
+function contentFileName(guid, page) {
+  return `content/${guid}-${page}.json`;
+}
+function parseContentFileName(name) {
+  const match = /^content\/(.+)-(\d+)\.json$/.exec(name);
+  return match === void 0 || match === null ? void 0 : { guid: match[1], page: Number(match[2]) };
+}
+function seedSourceKind(source) {
+  return typeof source === "function" ? "thunk" : isSeedFileSource(source) ? "file" : "inline";
+}
+var MIN_SCANNABLE_LENGTH = 6;
+async function collectNonPublicSeedValues(tableDefs) {
+  const found = [];
+  for (const def of tableDefs) {
+    if (def.seed === void 0) continue;
+    const exempt = new Set(def.publicSeed ?? []);
+    const guarded = tableColumns(def).filter((c) => isNonPublicColumn(c) && !exempt.has(c.name));
+    if (guarded.length === 0) continue;
+    const source = seedSourceKind(def.seed);
+    const rows = await resolveSeedRows(def.seed);
+    for (const row of rows) {
+      for (const col of guarded) {
+        const value = Object.hasOwn(row, col.name) ? row[col.name] : void 0;
+        if (value === void 0 || value === null) continue;
+        const scannable = typeof value === "string" && value.length >= MIN_SCANNABLE_LENGTH;
+        found.push({ table: def.name, column: col.name, value: String(value), scannable, source });
+      }
+    }
+  }
+  return found;
+}
+function seedRowsByTableGuid(files) {
+  const out = /* @__PURE__ */ new Map();
+  const parsed = files.flatMap((f) => {
+    const parsedName = parseContentFileName(f.name);
+    return parsedName === void 0 ? [] : [{ ...parsedName, content: f.content }];
+  }).sort((a, b) => a.page - b.page);
+  for (const entry of parsed) {
+    const payload = JSON.parse(entry.content).payload;
+    if (!Array.isArray(payload)) continue;
+    const rows = out.get(entry.guid) ?? [];
+    rows.push(...payload);
+    out.set(entry.guid, rows);
+  }
+  return out;
+}
+
+export {
+  isMissingFile,
+  hostedFileResolver,
+  hostedFileArchivePath,
+  SEED_PAGE_TARGET_BYTES,
+  resolveSeedRows,
+  coerceSeedRows,
+  paginateRows,
+  buildSeedContentFiles,
+  registerSeedHostedFiles,
+  seedSourceKind,
+  collectNonPublicSeedValues,
+  seedRowsByTableGuid
+};
+//# sourceMappingURL=chunk-U64O2MXY.js.map