@lunora/codegen 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/LUNORA_ERROR_CODES-CySpQPD3.mjs

@@ -0,0 +1,61 @@
+import { jsonSchemaFromNode, objectSchemaFromNodes } from '@lunora/values';
+
+const literalConst = (literalValue) => {
+  if (literalValue === void 0) {
+    return {};
+  }
+  const trimmed = literalValue.trim();
+  if (trimmed === "true") {
+    return { const: true };
+  }
+  if (trimmed === "false") {
+    return { const: false };
+  }
+  if (trimmed === "null") {
+    return { const: null, type: "null" };
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return { const: trimmed.slice(1, -1), type: "string" };
+  }
+  const asNumber = Number(trimmed);
+  if (!Number.isNaN(asNumber)) {
+    return { const: asNumber };
+  }
+  return { const: trimmed };
+};
+const irReader = {
+  constraints: () => void 0,
+  inner: (validator) => validator.inner,
+  isNullable: (validator) => validator.column?.notNull === false,
+  // `ValidatorIR.kind` is a loose `string` (build-time AST); narrow it to the
+  // shared reader's `ValidatorKind`. Unknown kinds fall through the mapper's
+  // `default` branch to an empty schema, exactly as before.
+  kind: (validator) => validator.kind,
+  literalSchema: (validator) => literalConst(validator.literalValue),
+  members: (validator) => validator.members ?? [],
+  shape: (validator) => validator.shape ?? {},
+  tableName: (validator) => validator.tableName,
+  valueChild: (validator) => validator.valueType
+};
+const validatorIrToJsonSchema = (validator) => jsonSchemaFromNode(validator, irReader);
+const objectSchema = (shape) => objectSchemaFromNodes(shape, irReader);
+const argsObjectSchema = (args) => objectSchema(args);
+const LUNORA_ERROR_CODES = [
+  "BAD_REQUEST",
+  "CONFLICT",
+  "COUNT_RLS_UNSUPPORTED",
+  "FORBIDDEN",
+  "FUNCTION_NOT_FOUND",
+  "INTERNAL",
+  "INTERNAL_SERVER_ERROR",
+  "METHOD_NOT_ALLOWED",
+  "NOT_FOUND",
+  "NOT_IMPLEMENTED",
+  "PAYLOAD_TOO_LARGE",
+  "TOO_MANY_REQUESTS",
+  "UNAUTHORIZED",
+  "UNPROCESSABLE",
+  "VALIDATION_ERROR"
+];
+
+export { LUNORA_ERROR_CODES, argsObjectSchema, literalConst, objectSchema, validatorIrToJsonSchema };

package/dist/packem_shared/OPENRPC_VERSION-B4i9Qp3v.mjs

@@ -0,0 +1,60 @@
+import { GENERATED_HEADER } from './GENERATED_HEADER-BiFXNUvo.mjs';
+import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
+import { argsObjectSchema, LUNORA_ERROR_CODES } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
+
+const OPENRPC_VERSION = "1.3.2";
+const inferredResultSchema = () => {
+  return { description: "Result is TS-inferred from the function's return type (no `.output()` declared); best-effort — any JSON." };
+};
+const rpcMethod = (definition) => {
+  const namespace = sanitizeNamespace(definition.filePath);
+  const functionPath = `${namespace}:${definition.exportName}`;
+  return {
+    description: `Invoke the \`${definition.kind}\` \`${functionPath}\` over the Lunora RPC envelope (POST /_lunora/rpc, body \`{ "functionPath": "${functionPath}", "args": { … } }\`).`,
+    errors: LUNORA_ERROR_CODES.map((code, index) => {
+      return { code: -32e3 - index, data: { code }, message: code };
+    }),
+    name: functionPath,
+    params: [
+      {
+        description: "The function's argument object (the RPC envelope's `args`).",
+        name: "args",
+        // A function with no declared args still takes an (empty) args
+        // object; `required` reflects whether the function declares any
+        // arguments at all.
+        required: Object.keys(definition.args).length > 0,
+        schema: argsObjectSchema(definition.args)
+      }
+    ],
+    result: {
+      name: "result",
+      schema: inferredResultSchema()
+    },
+    summary: `${definition.kind}: ${functionPath}`,
+    "x-lunora-function-kind": definition.kind,
+    // OpenRPC has no first-class tag grouping; surface the file namespace as
+    // an `x-tags` extension so tooling can group methods by source file.
+    "x-tags": [{ name: namespace }]
+  };
+};
+const buildOpenRpcDocument = (input) => {
+  const version = input.version ?? "0.0.0";
+  const rpcFunctions = input.functions.filter((definition) => definition.visibility !== "internal" && definition.kind !== "stream");
+  const methods = rpcFunctions.map((definition) => rpcMethod(definition)).toSorted((a, b) => a.name.localeCompare(b.name));
+  const document = {
+    info: {
+      description: "Auto-generated from @lunora/values-typed functions by @lunora/codegen. Do not edit — run `lunora codegen` to regenerate.",
+      title: "Lunora RPC",
+      version
+    },
+    methods,
+    openrpc: OPENRPC_VERSION
+  };
+  return document;
+};
+const emitOpenRpc = (input) => `${JSON.stringify(buildOpenRpcDocument(input), void 0, 2)}
+`;
+const emitOpenRpcModule = (document_) => `${GENERATED_HEADER}export const openRpcSpec: Record<string, unknown> = ${JSON.stringify(document_, void 0, 4)};
+`;
+
+export { OPENRPC_VERSION, buildOpenRpcDocument, emitOpenRpc, emitOpenRpcModule };