@lunora/config 1.0.0-alpha.80 → 1.0.0-alpha.82

package/dist/packem_shared/SCHEMA_EDIT_ENDPOINT-Bt2SNkpV.mjs

@@ -1,95 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
-import { classifyEdit, applyAdditiveEdit } from './applyAdditiveEdit-C-snTFEV.mjs';
-import { parseSchema } from './parseSchema-DSeyktvG.mjs';
-import { w as writeFileAtomic } from './write-atomic-B2REqapi.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 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 || edit === null || 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) };
-  }
-  writeFileAtomic(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/SEED_ENDPOINT-7izz_Jao.mjs

@@ -1,61 +0,0 @@
-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 || body === null || 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 };

package/dist/packem_shared/WORKERS_CACHE_MIN_DATE-CaXbS7CX.mjs

@@ -1,11 +0,0 @@
-const WORKERS_CACHE_MIN_DATE = "2026-05-01";
-const isCacheEnabled = (parsed) => {
-  if (!parsed) {
-    return false;
-  }
-  const topLevel = typeof parsed.cache === "object" && parsed.cache !== null && parsed.cache.enabled === true;
-  const inExports = typeof parsed.exports === "object" && parsed.exports !== null && Object.values(parsed.exports).some((entry) => typeof entry === "object" && entry !== null && entry.cache?.enabled === true);
-  return topLevel || inExports;
-};
-
-export { WORKERS_CACHE_MIN_DATE, isCacheEnabled };

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

@@ -1,25 +0,0 @@
-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/applyAdditiveEdit-C-snTFEV.mjs

@@ -1,228 +0,0 @@
-import { Project, SyntaxKind } from 'ts-morph';
-import { collectCalls } from './parseSchema-DSeyktvG.mjs';
-
-const IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
-const VALIDATOR_METHODS = /* @__PURE__ */ new Set([
-  "any",
-  "array",
-  "bigint",
-  "boolean",
-  "bytes",
-  "date",
-  "id",
-  "literal",
-  "null",
-  "number",
-  "object",
-  "optional",
-  "record",
-  "storage",
-  "string",
-  "timestamp",
-  "union"
-]);
-const isValidatorExpression = (node) => {
-  if (node.getKind() === SyntaxKind.ParenthesizedExpression) {
-    return isValidatorExpression(node.asKindOrThrow(SyntaxKind.ParenthesizedExpression).getExpression());
-  }
-  if (node.getKind() !== SyntaxKind.CallExpression) {
-    return false;
-  }
-  const call = node.asKindOrThrow(SyntaxKind.CallExpression);
-  const callee = call.getExpression();
-  if (callee.getKind() !== SyntaxKind.PropertyAccessExpression) {
-    return false;
-  }
-  const access = callee.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
-  if (access.getExpression().getKind() !== SyntaxKind.Identifier || access.getExpression().getText() !== "v" || !VALIDATOR_METHODS.has(access.getName())) {
-    return false;
-  }
-  return call.getArguments().every((argument) => isValidatorArgument(argument));
-};
-const isValidatorArgument = (node) => {
-  const kind = node.getKind();
-  if (kind === SyntaxKind.ParenthesizedExpression) {
-    return isValidatorArgument(node.asKindOrThrow(SyntaxKind.ParenthesizedExpression).getExpression());
-  }
-  if (kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.TrueKeyword || kind === SyntaxKind.FalseKeyword || kind === SyntaxKind.NullKeyword) {
-    return true;
-  }
-  if (kind === SyntaxKind.PrefixUnaryExpression) {
-    const unary = node.asKindOrThrow(SyntaxKind.PrefixUnaryExpression);
-    return unary.getOperand().getKind() === SyntaxKind.NumericLiteral;
-  }
-  if (kind === SyntaxKind.ObjectLiteralExpression) {
-    return node.asKindOrThrow(SyntaxKind.ObjectLiteralExpression).getProperties().every((property) => {
-      if (property.getKind() !== SyntaxKind.PropertyAssignment) {
-        return false;
-      }
-      const initializer = property.getInitializer();
-      return initializer !== void 0 && isValidatorArgument(initializer);
-    });
-  }
-  if (kind === SyntaxKind.ArrayLiteralExpression) {
-    return node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression).getElements().every((element) => isValidatorArgument(element));
-  }
-  return isValidatorExpression(node);
-};
-const isAllowedValidatorText = (validator) => {
-  if (typeof validator !== "string" || validator.trim().length === 0) {
-    return false;
-  }
-  const project = new Project({ compilerOptions: { allowJs: true }, useInMemoryFileSystem: true });
-  const sourceFile = project.createSourceFile("validator.ts", `const __v = (${validator});`, { overwrite: true });
-  if (project.getProgram().getSyntacticDiagnostics(sourceFile).length > 0) {
-    return false;
-  }
-  if (sourceFile.getStatements().length !== 1) {
-    return false;
-  }
-  const declaration = sourceFile.getVariableDeclaration("__v");
-  const initializer = declaration?.getInitializer();
-  return initializer !== void 0 && isValidatorExpression(initializer);
-};
-const ADDITIVE_KINDS = /* @__PURE__ */ new Set(["addIndex", "addOptionalColumn", "addTable"]);
-const classifyEdit = (edit) => ADDITIVE_KINDS.has(edit.kind) ? "additive" : "destructive";
-const isIdentifier = (value) => typeof value === "string" && IDENTIFIER_PATTERN.test(value);
-const validateAdditiveEdit = (edit) => {
-  if (!isIdentifier(edit.table)) {
-    return "invalid-identifier";
-  }
-  if (edit.kind === "addOptionalColumn") {
-    if (!isIdentifier(edit.column)) {
-      return "invalid-identifier";
-    }
-    if (!isAllowedValidatorText(edit.validator)) {
-      return "invalid-validator";
-    }
-  }
-  if (edit.kind === "addIndex") {
-    if (!isIdentifier(edit.name)) {
-      return "invalid-identifier";
-    }
-    if (!Array.isArray(edit.fields) || !edit.fields.every((field) => isIdentifier(field))) {
-      return "invalid-identifier";
-    }
-  }
-  return void 0;
-};
-const findTablesObject = (source) => {
-  const project = new Project({ compilerOptions: { allowJs: true }, useInMemoryFileSystem: true });
-  const sourceFile = project.createSourceFile("schema.ts", source, { overwrite: true });
-  let defineSchemaCall;
-  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    if (call.getExpression().getText() === "defineSchema") {
-      defineSchemaCall = call;
-      break;
-    }
-  }
-  if (defineSchemaCall === void 0) {
-    const aliased = sourceFile.getImportDeclarations().some((declaration) => declaration.getNamedImports().some((named) => named.getName() === "defineSchema" && named.getAliasNode() !== void 0));
-    return { reason: aliased ? "aliased-define-schema" : "no-define-schema" };
-  }
-  const tablesArgument = defineSchemaCall.getArguments()[0];
-  if (tablesArgument?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
-    return { reason: "non-object-argument" };
-  }
-  return { object: tablesArgument.asKindOrThrow(SyntaxKind.ObjectLiteralExpression), sourceFile };
-};
-const findTableProperty = (tablesObject, table) => {
-  for (const property of tablesObject.getProperties()) {
-    if (property.getKind() === SyntaxKind.PropertyAssignment && property.getNameNode().getText().replaceAll(/["']/gu, "") === table) {
-      return property;
-    }
-  }
-  return void 0;
-};
-const findDefineTableShape = (tableProperty) => {
-  const defineTableCall = tableProperty.getInitializer()?.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => call.getExpression().getText() === "defineTable");
-  const shape = defineTableCall?.getArguments()[0];
-  return shape?.getKind() === SyntaxKind.ObjectLiteralExpression ? shape.asKindOrThrow(SyntaxKind.ObjectLiteralExpression) : void 0;
-};
-const applyAddTable = (tablesObject, edit) => {
-  if (findTableProperty(tablesObject, edit.table) !== void 0) {
-    return "duplicate-table";
-  }
-  tablesObject.addPropertyAssignment({
-    initializer: `defineTable({
-        // Add your column validators here.
-        // Example:
-        // text: v.string(),
-        // createdAt: v.number(),
-    })`,
-    name: edit.table
-  });
-  return void 0;
-};
-const applyAddOptionalColumn = (tablesObject, edit) => {
-  const tableProperty = findTableProperty(tablesObject, edit.table);
-  if (tableProperty === void 0) {
-    return "unknown-table";
-  }
-  const shape = findDefineTableShape(tableProperty);
-  if (shape === void 0) {
-    return "unknown-table";
-  }
-  const exists = shape.getProperties().some(
-    (property) => property.getKind() === SyntaxKind.PropertyAssignment && property.getNameNode().getText().replaceAll(/["']/gu, "") === edit.column
-  );
-  if (exists) {
-    return "duplicate-column";
-  }
-  shape.addPropertyAssignment({ initializer: `v.optional(${edit.validator})`, name: edit.column });
-  return void 0;
-};
-const applyAddIndex = (tableProperty, edit) => {
-  if (tableProperty === void 0) {
-    return "unknown-table";
-  }
-  const initializer = tableProperty.getInitializer();
-  if (initializer === void 0) {
-    return "unknown-table";
-  }
-  const duplicate = collectCalls(initializer).some((call) => {
-    const expression = call.getExpression();
-    if (expression.getKind() !== SyntaxKind.PropertyAccessExpression) {
-      return false;
-    }
-    const access = expression.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
-    const [nameArgument] = call.getArguments();
-    return access.getName() === "index" && nameArgument?.getKind() === SyntaxKind.StringLiteral && nameArgument.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText() === edit.name;
-  });
-  if (duplicate) {
-    return "duplicate-index";
-  }
-  const fields = edit.fields.map((field) => JSON.stringify(field)).join(", ");
-  const options = edit.unique === true ? ", { unique: true }" : "";
-  tableProperty.setInitializer(`${initializer.getText()}.index(${JSON.stringify(edit.name)}, [${fields}]${options})`);
-  return void 0;
-};
-const applyAdditiveEdit = (source, edit) => {
-  if (classifyEdit(edit) === "destructive") {
-    return { ok: false, reason: "destructive" };
-  }
-  const additive = edit;
-  const invalid = validateAdditiveEdit(additive);
-  if (invalid !== void 0) {
-    return { ok: false, reason: invalid };
-  }
-  const located = findTablesObject(source);
-  if ("reason" in located) {
-    return { ok: false, reason: located.reason };
-  }
-  const { object: tablesObject, sourceFile } = located;
-  let failure;
-  if (additive.kind === "addTable") {
-    failure = applyAddTable(tablesObject, additive);
-  } else if (additive.kind === "addOptionalColumn") {
-    failure = applyAddOptionalColumn(tablesObject, additive);
-  } else {
-    failure = applyAddIndex(findTableProperty(tablesObject, additive.table), additive);
-  }
-  if (failure !== void 0) {
-    return { ok: false, reason: failure };
-  }
-  return { ok: true, text: sourceFile.getFullText() };
-};
-
-export { applyAdditiveEdit, classifyEdit };

package/dist/packem_shared/assetContentType-ByZjeV3D.mjs

@@ -1,72 +0,0 @@
-import { readFileSync, statSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { normalize, join, relative, isAbsolute, dirname } from 'node:path';
-
-const loadStudioAssets = (logger, resolveFrom = import.meta.url) => {
-  try {
-    const require = createRequire(resolveFrom);
-    return {
-      script: readFileSync(require.resolve("@lunora/studio/standalone/studio.js")),
-      styles: readFileSync(require.resolve("@lunora/studio/styles.css"))
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger?.warnOnce?.(`[lunora] studio assets unavailable (build @lunora/studio?): ${message}`);
-    return void 0;
-  }
-};
-const studioAssetsStamp = (resolveFrom = import.meta.url) => {
-  try {
-    const require = createRequire(resolveFrom);
-    const scriptMtime = statSync(require.resolve("@lunora/studio/standalone/studio.js")).mtimeMs;
-    const stylesMtime = statSync(require.resolve("@lunora/studio/styles.css")).mtimeMs;
-    return Math.max(scriptMtime, stylesMtime);
-  } catch {
-    return void 0;
-  }
-};
-const resolveStandaloneDirectory = (resolveFrom = import.meta.url) => {
-  try {
-    return dirname(createRequire(resolveFrom).resolve("@lunora/studio/standalone/studio.js"));
-  } catch {
-    return void 0;
-  }
-};
-const resolveContainedFile = (directory, fileName) => {
-  if (fileName === "" || fileName === "." || fileName === ".." || fileName.includes("/") || fileName.includes("\\") || fileName.includes("\0")) {
-    return void 0;
-  }
-  const resolved = normalize(join(directory, fileName));
-  const relativePath = relative(directory, resolved);
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath) || relativePath.includes("/") || relativePath.includes("\\")) {
-    return void 0;
-  }
-  return resolved;
-};
-const readStandaloneAsset = (fileName, resolveFrom = import.meta.url) => {
-  const directory = resolveStandaloneDirectory(resolveFrom);
-  if (directory === void 0) {
-    return void 0;
-  }
-  const resolved = resolveContainedFile(directory, fileName);
-  if (resolved === void 0) {
-    return void 0;
-  }
-  try {
-    return readFileSync(resolved);
-  } catch {
-    return void 0;
-  }
-};
-const isStandaloneModulePath = (pathname) => pathname.endsWith(".js") || pathname.endsWith(".js.map");
-const assetContentType = (fileName) => {
-  if (fileName.endsWith(".css")) {
-    return "text/css; charset=utf-8";
-  }
-  if (fileName.endsWith(".map")) {
-    return "application/json; charset=utf-8";
-  }
-  return "text/javascript; charset=utf-8";
-};
-
-export { assetContentType, isStandaloneModulePath, loadStudioAssets, readStandaloneAsset, resolveContainedFile, resolveStandaloneDirectory, studioAssetsStamp };