@lunora/codegen 1.0.0-alpha.55 → 1.0.0-alpha.56

package/dist/packem_shared/formatAdvisories-Cans5TWS.mjs

@@ -1,131 +0,0 @@
-import { runAdvisor } from '@lunora/advisor';
-
-const flattenIndexes = (table) => [
-  ...table.indexes.map((index) => {
-    return { fields: index.fields, kind: "index", name: index.name, unique: index.unique };
-  }),
-  ...table.searchIndexes.map((index) => {
-    return { fields: [index.field, ...index.filterFields ?? []], kind: "search", name: index.name };
-  }),
-  ...table.rankIndexes.map((index) => {
-    return { fields: [...index.sortBy.map((key) => key.field), ...index.partitionBy ?? []], kind: "rank", name: index.name };
-  }),
-  ...table.vectorIndexes.filter((index) => index.field !== void 0).map((index) => {
-    return { fields: [index.field], kind: "vector", name: index.name };
-  }),
-  ...(table.geoIndexes ?? []).map((index) => {
-    return { fields: [index.field], kind: "geo", name: index.name };
-  })
-];
-const columnKindsOf = (table) => {
-  const kinds = {};
-  for (const [fieldName, validator] of Object.entries(table.shape)) {
-    kinds[fieldName] = validator.kind === "optional" ? validator.inner?.kind ?? "optional" : validator.kind;
-  }
-  return kinds;
-};
-const toAdvisorSchema = (schema) => {
-  return {
-    rlsMode: schema.rlsMode,
-    tables: schema.tables.map((table) => {
-      return {
-        externallyManaged: table.externallyManaged ?? false,
-        externalSource: table.externalSource ? {
-          hasReconcile: table.externalSource.hasReconcile ?? false,
-          hasSoftDelete: table.externalSource.hasSoftDelete ?? false,
-          hasTenantBy: table.externalSource.hasTenantBy,
-          mode: table.externalSource.mode,
-          unanalyzable: table.externalSource.unanalyzable
-        } : void 0,
-        columnKinds: columnKindsOf(table),
-        fields: Object.keys(table.shape),
-        indexes: flattenIndexes(table),
-        isPublic: table.isPublic ?? false,
-        name: table.name,
-        relations: table.relations.map((relation) => {
-          return {
-            field: relation.field,
-            kind: relation.kind,
-            name: relation.name,
-            onDelete: relation.onDelete,
-            references: relation.references,
-            table: relation.table
-          };
-        }),
-        shardKind: typeof table.shardMode === "string" ? table.shardMode : "shardBy",
-        softDelete: table.softDelete,
-        ttl: table.ttl
-      };
-    })
-  };
-};
-const toAdvisorShapes = (shapes) => shapes.map((shape) => {
-  return { exportName: shape.exportName, file: `lunora/${shape.filePath}.ts`, table: shape.table };
-});
-const lintSchema = (options) => runAdvisor(
-  {
-    adminRoutes: options.adminRoutes,
-    aiRawRuns: options.aiRawRuns,
-    aiToolSideEffects: options.aiToolSideEffects,
-    argumentDerivedFetches: options.argumentDerivedFetches,
-    argValidators: options.argumentValidators,
-    authApiCalls: options.authApiCalls,
-    authConfigs: options.authConfigs,
-    browserUrlAccesses: options.browserUrlAccesses,
-    configCalls: options.configCalls,
-    containerKeyAccesses: options.containerKeyAccesses,
-    containerOverrides: options.containerOverrides,
-    containers: options.containers,
-    exportSinks: options.exportSinks,
-    failOpenGuards: options.failOpenGuards,
-    flagSecurityDefaults: options.flagSecurityDefaults,
-    geoIndexUsages: options.geoIndexUsages,
-    httpActionGuards: options.httpActionGuards,
-    httpHeaderWrites: options.httpHeaderWrites,
-    identityClaimReads: options.identityClaimReads,
-    imageDeliveryUrlAccesses: options.imageDeliveryUrlAccesses,
-    inserts: options.inserts,
-    kvKeyAccesses: options.kvKeyAccesses,
-    mailRecipientAccesses: options.mailRecipientAccesses,
-    maskProcedures: options.maskProcedures,
-    maskStrategies: options.maskStrategies,
-    mutatorWrites: options.mutatorWrites,
-    nondeterministicCalls: options.nondeterministicCalls,
-    normalizeIdAuthorizations: options.normalizeIdAuthorizations,
-    notifyCalls: options.notifyCalls,
-    notifyConfig: options.notifyConfig,
-    ownerFieldWrites: options.ownerFieldWrites,
-    paymentWebhooks: options.paymentWebhooks,
-    privilegedDispatches: options.privilegedDispatches,
-    procedureProtections: options.procedureProtections,
-    queries: options.queries ?? [],
-    queues: options.queues,
-    r2sqlCalls: options.r2sqlCalls,
-    ratelimitKeySelectors: options.ratelimitKeySelectors,
-    rawRowReturns: options.rawRowReturns,
-    relationLoads: options.relationLoads,
-    rlsProcedures: options.rlsProcedures,
-    schema: toAdvisorSchema(options.schema),
-    secretLiterals: options.secretLiterals,
-    shapes: options.shapes === void 0 ? void 0 : toAdvisorShapes(options.shapes),
-    softDeleteReads: options.softDeleteReads,
-    sqlInterpolations: options.sqlInterpolations,
-    storageKeyAccesses: options.storageKeyAccesses,
-    storageUploads: options.storageUploads,
-    vectorNamespaceAccesses: options.vectorNamespaceAccesses,
-    workflowCalls: options.workflowCalls,
-    workflows: options.workflows,
-    wranglerVariables: options.wranglerVariables
-  },
-  { source: "static" }
-);
-const formatAdvisories = (findings) => {
-  if (findings.length === 0) {
-    return "";
-  }
-  const header = `@lunora/codegen: ${String(findings.length)} schema advisor finding${findings.length === 1 ? "" : "s"}`;
-  const lines = findings.map((finding) => `  [${finding.level}] ${finding.name}: ${finding.detail}`);
-  return [header, ...lines].join("\n");
-};
-
-export { formatAdvisories, lintSchema };

package/dist/packem_shared/parse-validator-BDGV8iue.mjs

@@ -1,144 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { Node } from 'ts-morph';
-
-const FIELD_NAME_RE = /^[A-Za-z_$][\w$]*$/u;
-const COLUMN_MODIFIERS = /* @__PURE__ */ new Set(["$defaultFn", "$onUpdateFn", "$type", "default", "defaultNow", "nullable", "unique"]);
-const applyColumnModifier = (base, modifier) => {
-  const column = { notNull: true, ...base.column };
-  switch (modifier) {
-    case "$defaultFn":
-    case "default":
-    case "defaultNow": {
-      column.hasDefault = true;
-      break;
-    }
-    case "$onUpdateFn": {
-      column.hasOnUpdate = true;
-      break;
-    }
-    case "$type": {
-      break;
-    }
-    case "nullable": {
-      column.notNull = false;
-      break;
-    }
-    case "unique": {
-      column.unique = true;
-      break;
-    }
-  }
-  return { ...base, column };
-};
-const SCALAR_KINDS = /* @__PURE__ */ new Set(["any", "bigint", "boolean", "bytes", "date", "geoPoint", "null", "number", "string", "timestamp"]);
-const TRANSPARENT_MODIFIERS = /* @__PURE__ */ new Set(["check", "meta"]);
-const parseValidator = (expression) => {
-  if (Node.isCallExpression(expression)) {
-    return parseValidatorCall(expression);
-  }
-  return { kind: "any", sourceText: expression.getText() };
-};
-const parseObjectShape = (object) => {
-  const out = {};
-  for (const property of object.getProperties()) {
-    if (!Node.isPropertyAssignment(property)) {
-      continue;
-    }
-    const nameNode = property.getNameNode();
-    if (Node.isComputedPropertyName(nameNode)) {
-      continue;
-    }
-    const initializer = property.getInitializer();
-    if (!initializer) {
-      continue;
-    }
-    const fieldName = property.getName();
-    if (!FIELD_NAME_RE.test(fieldName)) {
-      throw new LunoraError("INTERNAL", `@lunora/codegen: field name is not a valid JS identifier: ${JSON.stringify(fieldName)}`);
-    }
-    out[fieldName] = parseValidator(initializer);
-  }
-  return out;
-};
-const parseArgument = (argument, fallback) => argument && Node.isExpression(argument) ? parseValidator(argument) : fallback;
-const renderLiteralSource = (node) => {
-  if (node === void 0) {
-    return "undefined";
-  }
-  if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
-    return JSON.stringify(node.getLiteralValue());
-  }
-  return node.getText();
-};
-const parseBuilderMember = (member, args) => {
-  if (SCALAR_KINDS.has(member)) {
-    return { kind: member };
-  }
-  const [first, second] = args;
-  switch (member) {
-    case "array": {
-      return { inner: parseArgument(first, { kind: "any" }), kind: "array" };
-    }
-    case "from": {
-      return { kind: "from" };
-    }
-    case "id": {
-      return { kind: "id", tableName: first && Node.isStringLiteral(first) ? first.getLiteralText() : "_unknown_" };
-    }
-    case "literal": {
-      return {
-        kind: "literal",
-        // Canonical source text — strings/templates are re-encoded via
-        // JSON.stringify (see renderLiteralSource) so escapes/backticks
-        // survive; numbers/booleans/null keep their verbatim text.
-        literalValue: renderLiteralSource(first)
-      };
-    }
-    case "object": {
-      return first && Node.isObjectLiteralExpression(first) ? { kind: "object", shape: parseObjectShape(first) } : { kind: "object", shape: {} };
-    }
-    case "optional": {
-      return { inner: parseArgument(first, { kind: "any" }), kind: "optional" };
-    }
-    case "record": {
-      return {
-        keyType: parseArgument(first, { kind: "string" }),
-        kind: "record",
-        valueType: parseArgument(second, { kind: "any" })
-      };
-    }
-    case "storage": {
-      return first && Node.isStringLiteral(first) ? { bucket: first.getLiteralText(), kind: "storage" } : { kind: "storage" };
-    }
-    case "union": {
-      return {
-        kind: "union",
-        members: args.filter((argument) => Node.isExpression(argument)).map((argument) => parseValidator(argument))
-      };
-    }
-    default: {
-      throw new LunoraError("INTERNAL", `Unsupported validator kind: ${member}`);
-    }
-  }
-};
-const parseValidatorCall = (call) => {
-  const callee = call.getExpression();
-  if (!Node.isPropertyAccessExpression(callee)) {
-    return { kind: "any", sourceText: call.getText() };
-  }
-  const member = callee.getName();
-  const args = call.getArguments();
-  if (COLUMN_MODIFIERS.has(member)) {
-    const receiver = callee.getExpression();
-    const base = Node.isExpression(receiver) ? parseValidator(receiver) : { kind: "any" };
-    return applyColumnModifier(base, member);
-  }
-  if (TRANSPARENT_MODIFIERS.has(member)) {
-    const receiver = callee.getExpression();
-    const base = Node.isExpression(receiver) ? parseValidator(receiver) : { kind: "any" };
-    return member === "check" ? { ...base, hasRefinement: true } : base;
-  }
-  return parseBuilderMember(member, args);
-};
-
-export { parseObjectShape as a, parseValidator as p };

package/dist/packem_shared/paths-BRd6JHuF.mjs

@@ -1,11 +0,0 @@
-const INDEX_SUFFIX = /\/index$/u;
-const NON_IDENTIFIER = /[^\dA-Za-z]/gu;
-const sanitizeNamespace = (filePath) => (
-  // `lunora/ratelimit/index.ts` surfaces as `api.ratelimit.*` (and dispatches as
-  // `ratelimit:fn`) rather than the noisy `api.ratelimit_index.*` — the registry
-  // convention. Only a trailing `/index` is dropped, so `lunora/index.ts` and
-  // `lunora/ratelimit/queries.ts` (→ `ratelimit_queries`) are unaffected.
-  filePath.replace(INDEX_SUFFIX, "").replaceAll(NON_IDENTIFIER, "_")
-);
-
-export { sanitizeNamespace as s };

package/dist/packem_shared/redact-oTmsol5A.mjs

@@ -1,33 +0,0 @@
-const HIGH_ENTROPY_TOKEN_RE = /[\w+/=-]{40,}/u;
-const LOWER_RE = /[a-z]/u;
-const UPPER_RE = /[A-Z]/u;
-const DIGIT_RE = /\d/u;
-const HEX_SECRET_RE = /\b(?:[\da-f]{32,}|[\dA-F]{32,})\b/u;
-const isHighEntropy = (value) => {
-  const token = HIGH_ENTROPY_TOKEN_RE.exec(value)?.[0];
-  if (token === void 0) {
-    return false;
-  }
-  return LOWER_RE.test(token) && UPPER_RE.test(token) && DIGIT_RE.test(token);
-};
-const isHexSecret = (value) => HEX_SECRET_RE.test(value);
-const STRIPE_LIVE_KEY_RE = /\b(?:sk|rk)_live_[\dA-Za-z]{20,}/u;
-const AWS_ACCESS_KEY_RE = /\bAKIA[\dA-Z]{16}\b/u;
-const GITHUB_TOKEN_RE = /\bgh[posru]_[\dA-Za-z]{36,}/u;
-const OPENAI_KEY_RE = /\bsk-[\dA-Za-z]{32,}/u;
-const SLACK_TOKEN_RE = /\bxox[abprs]-[\dA-Za-z-]{10,}/u;
-const PRIVATE_KEY_RE = /-----BEGIN(?: [A-Z]+)? PRIVATE KEY-----/u;
-const SECRET_RULES = [
-  { kind: "stripe_live_key", test: (value) => STRIPE_LIVE_KEY_RE.test(value) },
-  { kind: "aws_access_key", test: (value) => AWS_ACCESS_KEY_RE.test(value) },
-  { kind: "github_token", test: (value) => GITHUB_TOKEN_RE.test(value) },
-  { kind: "openai_key", test: (value) => OPENAI_KEY_RE.test(value) },
-  { kind: "slack_token", test: (value) => SLACK_TOKEN_RE.test(value) },
-  { kind: "private_key", test: (value) => PRIVATE_KEY_RE.test(value) },
-  { kind: "high_entropy", test: isHighEntropy },
-  { kind: "hex_secret", test: isHexSecret }
-];
-const secretKindOf = (value) => SECRET_RULES.find((rule) => rule.test(value))?.kind;
-const redact = (value) => `${value.slice(0, 4)}…(${String(value.length)} chars)`;
-
-export { SECRET_RULES, redact, secretKindOf };

package/dist/packem_shared/schemaFromIr-DTYsLBaA.mjs

@@ -1,57 +0,0 @@
-const parseLiteral = (text) => {
-  try {
-    return JSON.parse(text);
-  } catch {
-    const trimmed = text.trim();
-    if (trimmed.length >= 2 && (trimmed.startsWith("'") || trimmed.startsWith('"')) && trimmed.at(-1) === trimmed[0]) {
-      return trimmed.slice(1, -1);
-    }
-    return trimmed;
-  }
-};
-const convertValidator = (ir) => {
-  const meta = {};
-  if (ir.column !== void 0) {
-    meta.column = {
-      // A non-undefined `defaultValue` is the sentinel `hasServerDefault`
-      // reads to skip the column (the server fills `.default()`/`.$defaultFn()`).
-      // eslint-disable-next-line unicorn/no-null -- null is a deliberate non-undefined sentinel here
-      defaultValue: ir.column.hasDefault === true ? null : void 0,
-      notNull: ir.column.notNull,
-      unique: ir.column.unique
-    };
-  }
-  if (ir.inner !== void 0) {
-    meta.inner = convertValidator(ir.inner);
-  }
-  if (ir.members !== void 0) {
-    meta.members = ir.members.map((member) => convertValidator(member));
-  }
-  if (ir.shape !== void 0) {
-    meta.shape = Object.fromEntries(Object.entries(ir.shape).map(([field, child]) => [field, convertValidator(child)]));
-  }
-  if (ir.tableName !== void 0) {
-    meta.tableName = ir.tableName;
-  }
-  if (ir.literalValue !== void 0) {
-    meta.value = parseLiteral(ir.literalValue);
-  }
-  if (ir.keyType !== void 0) {
-    meta.keyValidator = convertValidator(ir.keyType);
-  }
-  if (ir.valueType !== void 0) {
-    meta.valueValidator = convertValidator(ir.valueType);
-  }
-  return { _meta: meta, kind: ir.kind };
-};
-const schemaFromIr = (ir) => {
-  const tables = Object.fromEntries(
-    ir.tables.map((table) => [
-      table.name,
-      { shape: Object.fromEntries(Object.entries(table.shape).map(([field, validator]) => [field, convertValidator(validator)])) }
-    ])
-  );
-  return { tables };
-};
-
-export { schemaFromIr };