@lunora/codegen 0.0.0 → 1.0.0-alpha.1

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

@@ -0,0 +1,132 @@
+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", "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 Error(`@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 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",
+        // Captures the source text — for string/number/boolean/null literals
+        // this matches the TS type representation directly.
+        literalValue: first ? first.getText() : "undefined"
+      };
+    }
+    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 Error(`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();
+    return Node.isExpression(receiver) ? parseValidator(receiver) : { kind: "any" };
+  }
+  return parseBuilderMember(member, args);
+};
+
+export { parseObjectShape as a, parseValidator as p };

package/dist/packem_shared/paths-BRd6JHuF.mjs

@@ -0,0 +1,11 @@
+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/schemaFromIr-DTYsLBaA.mjs

@@ -0,0 +1,57 @@
+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 };

package/package.json

@@ -1,31 +1,59 @@
 {
   "name": "@lunora/codegen",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Code generator for Lunora: emits _generated/{api,server,dataModel}.ts from your schema",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "codegen",
+    "durable-objects",
+    "lunora",
+    "schema",
+    "ts-morph",
+    "type-safe",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/codegen"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "codegen",
-    "schema",
-    "type-safe",
-    "ts-morph"
+  "files": [
+    "dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/advisor": "1.0.0-alpha.1",
+    "@lunora/container": "1.0.0-alpha.1",
+    "@lunora/scheduler": "1.0.0-alpha.1",
+    "@lunora/values": "1.0.0-alpha.1",
+    "@lunora/workflow": "1.0.0-alpha.1",
+    "ts-morph": "^28.0.0"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }