@lunora/config 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/discoverSchemaInfo-DWtypqpP.mjs

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { discoverSchema } from '@lunora/codegen';
+import { Project } from 'ts-morph';
+import { join } from 'node:path';
+
+const discoverSchemaInfo = (projectRoot, schemaDirectory) => {
+  const schemaPath = join(projectRoot, schemaDirectory, "schema.ts");
+  if (!existsSync(schemaPath)) {
+    return { info: void 0 };
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    const schema = discoverSchema(project, schemaPath);
+    return {
+      info: {
+        hasGlobalTable: schema.tables.some((table) => table.shardMode === "global"),
+        vectorIndexNames: schema.vectorIndexes.map((index) => index.name)
+      }
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error), info: void 0 };
+  }
+};
+
+export { discoverSchemaInfo };

package/dist/packem_shared/discoverWorkflowInfo-CedvR0mn.mjs

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { WORKFLOWS_FILENAME, discoverWorkflows } from '@lunora/codegen';
+import { Project } from 'ts-morph';
+import { join } from 'node:path';
+
+const discoverWorkflowInfo = (projectRoot, schemaDirectory) => {
+  const workflowsPath = join(projectRoot, schemaDirectory, WORKFLOWS_FILENAME);
+  if (!existsSync(workflowsPath)) {
+    return { workflows: [] };
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    return { workflows: discoverWorkflows(project, join(projectRoot, schemaDirectory)) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error), workflows: [] };
+  }
+};
+
+export { discoverWorkflowInfo };

package/dist/packem_shared/findWranglerFile-DwSuC-Kn.mjs

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { parse } from 'jsonc-parser';
+import { join } from 'node:path';
+
+const WRANGLER_FILES = ["wrangler.jsonc", "wrangler.json"];
+const findWranglerFile = (projectRoot) => {
+  for (const candidate of WRANGLER_FILES) {
+    const fullPath = join(projectRoot, candidate);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return void 0;
+};
+const readWranglerJsonc = (wranglerPath) => {
+  const text = readFileSync(wranglerPath, "utf8");
+  const parseErrors = [];
+  const value = parse(text, parseErrors, { allowTrailingComma: true });
+  if (parseErrors.length > 0 || value === null || typeof value !== "object") {
+    return { parsed: void 0, text };
+  }
+  return { parsed: value, text };
+};
+
+export { WRANGLER_FILES, findWranglerFile, readWranglerJsonc };

package/dist/packem_shared/formatLunoraEvent-D2fDeGB6.mjs

@@ -0,0 +1,86 @@
+const LUNORA_EVENT_SOURCE = "lunora";
+const ROOT_SHARD_NAME = "__root__";
+const asString = (value) => typeof value === "string" ? value : "";
+const asStringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const formatDuration = (value) => typeof value === "number" && Number.isFinite(value) ? `${String(Math.round(value))}ms` : "?ms";
+const toLineLevel = (rawLevel) => {
+  if (rawLevel === "error") {
+    return "error";
+  }
+  if (rawLevel === "warn") {
+    return "warn";
+  }
+  return "info";
+};
+const parseLunoraEvent = (line) => {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const event = parsed;
+  return event.source === LUNORA_EVENT_SOURCE ? event : void 0;
+};
+const labelFor = (functionPath, event) => {
+  const shard = asString(event.shard);
+  return shard === "" || shard === ROOT_SHARD_NAME ? functionPath : `${functionPath}@${shard}`;
+};
+const formatRequest = (event, functionPath) => {
+  const failed = event.outcome === "error";
+  const parts = [labelFor(functionPath, event), failed ? "error" : "ok", formatDuration(event.durationMs)];
+  const read = asStringList(event.tablesRead);
+  const written = asStringList(event.tablesWritten);
+  if (read.length > 0) {
+    parts.push(`read[${read.join(",")}]`);
+  }
+  if (written.length > 0) {
+    parts.push(`write[${written.join(",")}]`);
+  }
+  if (event.cacheHit === true) {
+    parts.push("cached");
+  }
+  const errorMessage = asString(event.error);
+  if (failed && errorMessage !== "") {
+    parts.push(errorMessage);
+  }
+  return { kind: "rpc", level: failed ? "error" : "info", text: parts.join("  ") };
+};
+const formatContainer = (event) => {
+  const name = asString(event.container) || "<unknown>";
+  const instance = asString(event.instance);
+  const transition = asString(event.event) || "event";
+  const shortId = instance === "" || instance === "unknown" ? "" : `#${instance.slice(0, 8)}`;
+  const message = asString(event.message);
+  const parts = [`container:${name}${shortId}`, transition];
+  if (message !== "") {
+    parts.push(message);
+  }
+  return { kind: "log", level: event.event === "error" ? "error" : "info", text: parts.join("  ") };
+};
+const formatLunoraEvent = (line) => {
+  const event = parseLunoraEvent(line);
+  if (!event) {
+    return void 0;
+  }
+  const functionPath = asString(event.function) || "<unknown>";
+  if (event.type === "log") {
+    return { kind: "log", level: toLineLevel(asString(event.level)), text: `${labelFor(functionPath, event)}  ${asString(event.message)}`.trimEnd() };
+  }
+  if (event.type === "request") {
+    return formatRequest(event, functionPath);
+  }
+  if (event.type === "container") {
+    return formatContainer(event);
+  }
+  return void 0;
+};
+
+export { LUNORA_EVENT_SOURCE, formatLunoraEvent };

package/dist/packem_shared/handlePolicyScaffoldRequest-CiC2IGKx.mjs

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { join, isAbsolute, relative } from 'node:path';
+import { runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { classifyPolicyEdit, scaffoldPolicyFile, wireRlsIntoProcedure } from './classifyPolicyEdit-BHeAqF8P.mjs';
+
+const POLICY_SCAFFOLD_ENDPOINT = "/__lunora/policy-scaffold";
+const statusForFailure = (reason) => {
+  if (reason === "unknown-procedure") {
+    return 404;
+  }
+  if (reason === "already-wired") {
+    return 409;
+  }
+  return reason === "destructive" ? 409 : 422;
+};
+const writeAtomic = (path, text) => {
+  const temporaryPath = `${path}.lunora-tmp`;
+  writeFileSync(temporaryPath, text, "utf8");
+  renameSync(temporaryPath, path);
+};
+const runCodegenForResponse = (request, okBody) => {
+  let diagnostics = [];
+  try {
+    runCodegen({ lunoraDirectory: request.schemaDirectory ?? "lunora", projectRoot: request.projectRoot });
+  } catch (error) {
+    if (error instanceof CodegenDiagnosticError) {
+      diagnostics = [error.message];
+    } else {
+      return { body: { error: error instanceof Error ? error.message : String(error), ok: false }, status: 500 };
+    }
+  }
+  return { body: { ...okBody, diagnostics, ok: true }, status: 200 };
+};
+const refuseDestructive = (edit) => {
+  return {
+    body: {
+      edit,
+      message: "Rewriting an existing policy predicate changes evaluation semantics and must be done by hand. The scaffolder only adds new, deny-by-default rules.",
+      needsManualEdit: true,
+      ok: false
+    },
+    status: 409
+  };
+};
+const handleScaffoldPolicy = (request, edit) => {
+  const result = scaffoldPolicyFile(edit);
+  if (!result.ok) {
+    return { body: { error: result.reason, ok: false }, status: statusForFailure(result.reason) };
+  }
+  const lunoraDirectory = request.schemaDirectory ?? "lunora";
+  const targetPath = join(request.projectRoot, lunoraDirectory, result.fileName);
+  if (existsSync(targetPath)) {
+    return { body: { error: "file-exists", fileName: result.fileName, ok: false }, status: 409 };
+  }
+  writeAtomic(targetPath, result.source);
+  return runCodegenForResponse(request, { fileName: result.fileName });
+};
+const resolveProcedureFile = (projectRoot, lunoraDirectory, filePath) => {
+  if (typeof filePath !== "string" || filePath.length === 0 || isAbsolute(filePath) || filePath.includes("\\")) {
+    return void 0;
+  }
+  const lunoraRoot = join(projectRoot, lunoraDirectory);
+  const resolved = join(lunoraRoot, `${filePath}.ts`);
+  const relativePath = relative(lunoraRoot, resolved);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    return void 0;
+  }
+  return resolved;
+};
+const handleWireRls = (request, edit) => {
+  const procedurePath = resolveProcedureFile(request.projectRoot, request.schemaDirectory ?? "lunora", edit.filePath);
+  if (procedurePath === void 0 || !existsSync(procedurePath)) {
+    return { body: { error: "unknown-procedure", ok: false }, status: 404 };
+  }
+  const wired = wireRlsIntoProcedure(readFileSync(procedurePath, "utf8"), edit);
+  if (!wired.ok) {
+    return { body: { error: wired.reason, ok: false }, status: statusForFailure(wired.reason) };
+  }
+  writeAtomic(procedurePath, wired.text);
+  return runCodegenForResponse(request, { exportName: edit.exportName });
+};
+const handlePolicyScaffoldRequest = (request) => {
+  if (request.method !== "POST") {
+    return { body: { error: "method-not-allowed", ok: false }, status: 405 };
+  }
+  const { body } = request;
+  if (body === void 0 || typeof body !== "object" || typeof body.kind !== "string") {
+    return { body: { error: "invalid-edit", ok: false }, status: 400 };
+  }
+  const edit = body;
+  if (classifyPolicyEdit(edit) === "destructive") {
+    return refuseDestructive(edit);
+  }
+  if (edit.kind === "scaffoldPolicy") {
+    return handleScaffoldPolicy(request, edit);
+  }
+  if (edit.kind === "wireRls") {
+    return handleWireRls(request, edit);
+  }
+  throw new Error(`unhandled additive policy edit kind: ${String(edit.kind)}`);
+};
+
+export { POLICY_SCAFFOLD_ENDPOINT, handlePolicyScaffoldRequest };

package/dist/packem_shared/handleSchemaEditRequest-Df-Wrix-.mjs

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { classifyEdit, applyAdditiveEdit } from './applyAdditiveEdit-C-snTFEV.mjs';
+import { parseSchema } from './parseSchema-DSeyktvG.mjs';
+import { join } from 'node:path';
+
+const SCHEMA_EDIT_ENDPOINT = "/__lunora/schema-edit";
+const statusForFailure = (reason) => {
+  if (reason === "destructive") {
+    return 409;
+  }
+  if (reason === "duplicate-table" || reason === "duplicate-column" || reason === "duplicate-index") {
+    return 409;
+  }
+  if (reason === "unknown-table") {
+    return 404;
+  }
+  if (reason === "invalid-identifier" || reason === "invalid-validator") {
+    return 400;
+  }
+  return 422;
+};
+const parseFailureResponse = (result) => {
+  return {
+    body: { error: result.reason, ok: false },
+    status: 422
+  };
+};
+const readSchema = (schemaPath) => {
+  if (!existsSync(schemaPath)) {
+    return { response: { body: { error: "no-schema-file", ok: false }, status: 404 } };
+  }
+  const parsed = parseSchema(readFileSync(schemaPath, "utf8"));
+  if (!parsed.ok) {
+    return { response: parseFailureResponse(parsed) };
+  }
+  return { tables: parsed.tables };
+};
+const writeSchemaAtomic = (schemaPath, text) => {
+  const temporaryPath = `${schemaPath}.lunora-tmp`;
+  writeFileSync(temporaryPath, text, "utf8");
+  renameSync(temporaryPath, schemaPath);
+};
+const needsMigrationResponse = (edit) => {
+  return {
+    body: {
+      edit,
+      message: "This edit changes stored data and must go through a migration. Review the migration before applying.",
+      needsMigration: true,
+      ok: false
+    },
+    status: 409
+  };
+};
+const handlePost = (request, schemaPath) => {
+  const edit = request.body;
+  if (edit === void 0 || typeof edit !== "object" || typeof edit.kind !== "string") {
+    return { body: { error: "invalid-edit", ok: false }, status: 400 };
+  }
+  if (classifyEdit(edit) === "destructive") {
+    return needsMigrationResponse(edit);
+  }
+  if (!existsSync(schemaPath)) {
+    return { body: { error: "no-schema-file", ok: false }, status: 404 };
+  }
+  const applied = applyAdditiveEdit(readFileSync(schemaPath, "utf8"), edit);
+  if (!applied.ok) {
+    return { body: { error: applied.reason, ok: false }, status: statusForFailure(applied.reason) };
+  }
+  writeSchemaAtomic(schemaPath, applied.text);
+  let diagnostics = [];
+  try {
+    runCodegen({ lunoraDirectory: request.schemaDirectory ?? "lunora", projectRoot: request.projectRoot });
+  } catch (error) {
+    if (error instanceof CodegenDiagnosticError) {
+      diagnostics = [error.message];
+    } else {
+      return { body: { error: error instanceof Error ? error.message : String(error), ok: false }, status: 500 };
+    }
+  }
+  const parsed = parseSchema(applied.text);
+  return {
+    body: { diagnostics, ok: true, tables: parsed.ok ? parsed.tables : [] },
+    status: 200
+  };
+};
+const handleSchemaEditRequest = (request) => {
+  const schemaPath = join(request.projectRoot, request.schemaDirectory ?? "lunora", "schema.ts");
+  if (request.method === "GET") {
+    const read = readSchema(schemaPath);
+    return "response" in read ? read.response : { body: { ok: true, tables: read.tables }, status: 200 };
+  }
+  if (request.method === "POST") {
+    return handlePost(request, schemaPath);
+  }
+  return { body: { error: "method-not-allowed", ok: false }, status: 405 };
+};
+
+export { SCHEMA_EDIT_ENDPOINT, handleSchemaEditRequest };

package/dist/packem_shared/handleSeedRequest-DVCjaGO-.mjs

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs';
+import { discoverSchema, schemaFromIr } from '@lunora/codegen';
+import { seedPlan } from '@lunora/seed';
+import { Project } from 'ts-morph';
+import { join } from 'node:path';
+
+const SEED_ENDPOINT = "/__lunora/seed";
+const MAX_SEED_ROWS = 1e3;
+const jsonReplacer = (_key, value) => {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return [...new Uint8Array(value)];
+  }
+  return value;
+};
+const clampCount = (count) => {
+  if (typeof count !== "number" || !Number.isFinite(count)) {
+    return 10;
+  }
+  return Math.min(Math.max(1, Math.floor(count)), MAX_SEED_ROWS);
+};
+const handleSeedRequest = (request) => {
+  if (request.method !== "POST") {
+    return { body: { error: "method-not-allowed", ok: false }, status: 405 };
+  }
+  const { body } = request;
+  if (body === void 0 || typeof body !== "object") {
+    return { body: { error: "invalid-request", ok: false }, status: 400 };
+  }
+  const { count, existingIds, seed, table } = body;
+  if (typeof table !== "string" || table.length === 0) {
+    return { body: { error: "missing-table", ok: false }, status: 400 };
+  }
+  const lunoraDirectory = request.schemaDirectory ?? "lunora";
+  const schemaPath = join(request.projectRoot, lunoraDirectory, "schema.ts");
+  if (!existsSync(schemaPath)) {
+    return { body: { error: "schema-not-found", ok: false }, status: 404 };
+  }
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const ir = discoverSchema(project, schemaPath);
+  if (!ir.tables.some((candidate) => candidate.name === table)) {
+    return { body: { error: "unknown-table", ok: false, table }, status: 404 };
+  }
+  const schema = schemaFromIr(ir);
+  const plan = seedPlan(schema, {
+    // Pass every sampled parent table as `existingIds` so the generator links
+    // to live rows and never fabricates parents — matching the studio's
+    // "existing rows are not affected, FKs point at what's there" semantics.
+    existingIds: existingIds ?? {},
+    defaultCount: clampCount(count),
+    only: [table],
+    seed: seed ?? 0
+  });
+  const rows = plan.find((entry) => entry.table === table)?.rows ?? [];
+  const jsonSafeRows = JSON.parse(JSON.stringify(rows, jsonReplacer));
+  return { body: { ok: true, rows: jsonSafeRows }, status: 200 };
+};
+
+export { SEED_ENDPOINT, handleSeedRequest };