@lunora/codegen 1.0.0-alpha.35 → 1.0.0-alpha.351

package/dist/packem_shared/emitCrons-lc-hnJYn.mjs

@@ -0,0 +1,96 @@
+import{G as i,d as c}from"./shared-8vTRkL2-.mjs";import{i as m}from"./schema-BgM8A3XV.mjs";const u=r=>r?`${i}/**
+ * The \`SchedulerDO\` Durable Object class, re-exported so a worker entry can
+ * forward it — wrangler binds only what the entry exports:
+ *
+ * \`export * from "./lunora/_generated/scheduler.js";\`
+ *
+ * A Vite-first (class-A) app needs no such line: the generated worker entry
+ * forwards this module for you whenever it exists.
+ */
+export { SchedulerDO } from "@lunora/scheduler";
+`:"",y=(r,t)=>r.some(o=>m(o))?`${i}/**
+ * The \`ShardRegistryDO\` Durable Object class — the live set of shard keys per
+ * \`.shardBy()\` table, which cross-shard export, CDC sync and migrations fan out
+ * to. Re-exported so a worker entry can forward it (wrangler binds only what the
+ * entry exports), next to \`.shardRegistry((env) => env.SHARD_REGISTRY)\`:
+ *
+ * \`export { ShardRegistryDO } from "./lunora/_generated/shardRegistry.js";\`
+ *
+ * Name the class in a hand-written entry: binding inference provisions
+ * \`SHARD_REGISTRY\` off the entry's named exports, and cannot see through an
+ * \`export *\`. A Vite-first (class-A) app needs neither line — its generated
+ * worker entry does both whenever this module exists.
+ */
+export { ShardRegistryDO } from "${c(t).do}";
+`:"",w=r=>`${i}/**
+ * Host the shard, the scheduler and the shard registry in ONE Durable Object
+ * class, so the app spends one of the account's classes instead of three. A
+ * Vite-first (class-A) app needs nothing more: its generated worker entry builds
+ * \`LunoraDO\` from these. A hand-written entry does the same by hand:
+ *
+ * \`export const LunoraDO = mergeDurableObjects({ shard: app.ShardDO, scheduler: SchedulerDO, shardRegistry: ShardRegistryDO });\`
+ *
+ * and passes \`roleNamespace(env.SHARD, "scheduler")\` / \`roleNamespace(env.SHARD, "shardRegistry")\`
+ * to \`.scheduler()\` / \`.shardRegistry()\`. Merge before the first deploy only:
+ * data already in \`ShardDO\` does not move, and a deployed merge cannot be undone.
+ */
+export { mergeDurableObjects, roleNamespace } from "${c(r).do}";
+`,O=r=>{const t=new Map;for(const n of r){const d=t.get(n.cron);d?d.push(n):t.set(n.cron,[n])}const o=[...t.keys()].map(n=>`    ${JSON.stringify(n)},`).join(`
+`),e=o.length>0?`
+${o}
+`:"",s=[...t.entries()].map(([n,d])=>{const l=d.map(a=>{const f=a.workflow?`workflow: ${JSON.stringify(a.workflow.className)}`:`functionPath: ${JSON.stringify(a.functionPath)}`;return`        { name: ${JSON.stringify(a.name)}, ${f}, args: ${JSON.stringify(a.args)} },`}).join(`
+`);return`    ${JSON.stringify(n)}: [
+${l}
+    ],`}).join(`
+`),h=s.length>0?`
+${s}
+`:"";return`${i}/**
+ * One scheduled cron invocation. Exactly one target is set: \`functionPath\` is
+ * the \`namespace:fn\` dispatch ref (matches \`__lunoraRef\`), invoked on the
+ * shard; \`workflow\` is a workflow class name (its \`ctx.exports\` key) whose durable workflow is
+ * started fresh per fire. \`args\` are forwarded verbatim (a workflow's become
+ * its \`params\`).
+ */
+export interface LunoraCronJob {
+    args: Record<string, unknown>;
+    functionPath?: string;
+    name: string;
+    workflow?: string;
+}
+
+/**
+ * Deduplicated cron schedules — mirror of wrangler's \`triggers.crons\`. The
+ * Lunora vite plugin keeps \`wrangler.jsonc\` in sync with this array.
+ */
+export const LUNORA_CRON_TRIGGERS: ReadonlyArray<string> = [${e}];
+
+/**
+ * Dispatcher map keyed by cron expression. The Worker's \`scheduled()\` handler
+ * looks up \`event.cron\` here and dispatches every job in the list.
+ */
+export const LUNORA_CRONS: Record<string, ReadonlyArray<LunoraCronJob>> = {${h}};
+`},S=r=>{const t=[...r].toSorted((e,s)=>e.name.localeCompare(s.name)).map(e=>{const s=[`name: ${JSON.stringify(e.name)}`,`table: ${JSON.stringify(e.table)}`];return e.field!==void 0&&s.push(`field: ${JSON.stringify(e.field)}`),e.dimensions!==void 0&&s.push(`dimensions: ${JSON.stringify(e.dimensions)}`),e.metric!==void 0&&s.push(`metric: ${JSON.stringify(e.metric)}`),e.metadata!==void 0&&s.push(`metadata: ${JSON.stringify(e.metadata)}`),`    { ${s.join(", ")} },`}).join(`
+`),o=t.length>0?`
+${t}
+`:"";return`${i}/**
+ * One vector index declared in \`schema.ts\` — an inline \`.vectorize()\` column
+ * or a standalone \`defineVectorIndex()\`. \`field\` is the source column (absent
+ * for a \`select\`-derived Shape B index); \`metadata\` lists the row fields
+ * mirrored into Vectorize for filtering.
+ */
+export interface LunoraVectorIndex {
+    dimensions?: number;
+    field?: string;
+    metadata?: ReadonlyArray<string>;
+    metric?: "cosine" | "dot-product" | "euclidean";
+    name: string;
+    table: string;
+}
+
+/**
+ * Static registry of every vector index in the schema, sorted by name.
+ * Vectorize cannot enumerate indexes at runtime, so the worker passes this to
+ * \`createWorker({ vectorIntrospector })\` to back the studio's vector browser.
+ */
+export const LUNORA_VECTOR_INDEXES: ReadonlyArray<LunoraVectorIndex> = [${o}];
+`},b=r=>[...new Set(r.map(t=>t.cron))];export{O as emitCrons,w as emitDurableObjects,u as emitScheduler,y as emitShardRegistry,S as emitVectors,b as emitWranglerCronTriggers};

package/dist/packem_shared/emitDataModel-CuFqq97x.mjs

@@ -0,0 +1,114 @@
+import{r as k}from"./qualifiers-Bl5fSmav.mjs";import{a as i,e as o,v as d,f as v,G as M}from"./shared-8vTRkL2-.mjs";const _="schema",w=a=>{for(const e of a.tables)i(e.name,"table name");const l=a.tables.map(e=>`"${e.name}"`).join(" | ")||"never",m=a.tables.filter(e=>e.extensionKey===void 0).map(e=>`"${e.name}"`).join(" | ")||"never",p=a.tables.map(e=>{const t=Object.entries(e.shape).map(([g,r])=>{const s=o(g);if(r.kind==="optional"){const h=r.inner?d(r.inner):"unknown";return`    ${s}?: ${h};`}return`    ${s}: ${d(r)};`}).join(`
+`),n=t?`
+${t}
+`:"",N=e.commitOrdered===!0?`
+    _commitSeq: number;`:"";return`export interface Doc_${e.name} {
+    _id: Id<"${e.name}">;
+    _creationTime: number;${N}${n}}`}).join(`
+
+`),c=a.tables.map(e=>`    ${e.name}: Doc_${e.name};`).join(`
+`),y=a.tables.map(e=>{const t=e.indexes.map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),x=a.tables.map(e=>{const t=e.searchIndexes.map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),b=a.tables.map(e=>{const t=e.rankIndexes.map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),f=a.tables.map(e=>{const t=e.shardMode==="global"?"":(e.geoIndexes??[]).map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),T=a.vectorIndexes.map(e=>JSON.stringify(e.name)).join(" | ")||"never",$=a.tables.map(e=>v(e)).join(`
+
+`),u=a.tables.map(e=>`    ${e.name}: Insert_${e.name};`).join(`
+`),I=a.tables.map(e=>{const t=e.relations.map(n=>(i(n.table,"relation target table"),n.kind==="one"?`        ${o(n.name)}: OneRelation<"${n.table}", ${JSON.stringify(n.field)}>;`:`        ${o(n.name)}: ManyRelation<"${n.table}">;`)).join(`
+`);return t?`    ${e.name}: {
+${t}
+    };`:`    ${e.name}: {};`}).join(`
+`);return k(`${M}export type TableName = ${l};
+
+/**
+ * The tables **this app declared** — every {@link TableName} except those an add-on
+ * contributed through \`defineSchema(...).extend(...)\`.
+ *
+ * An add-on's tables are real tables and stay in \`TableName\` (they are queryable,
+ * they appear in \`DataModel\`), but an app enumerating "my tables" should not have to
+ * know they exist: an account-deletion sweep, an export, a migration allowlist, or a
+ * helper generic over a table union is about the app's own data, and every add-on
+ * added or removed would otherwise silently change the correct answer.
+ *
+ * \`\`\`ts
+ * // Doesn't need to mention \`ratelimit_buckets\`, and won't drift when an add-on lands.
+ * const EXPORTED: readonly AppTableName[] = ["nodes", "tagColors"];
+ * \`\`\`
+ */
+export type AppTableName = ${m};
+
+export type Id<TName extends string> = string & { readonly __table: TName };
+
+${p}
+
+export interface DataModel {
+${c}
+}
+
+export type Doc<T extends keyof DataModel> = DataModel[T];
+
+/**
+ * Per-table index name union. \`never\` for tables without secondary indexes.
+ * Used by \`TableReader.withIndex()\` to constrain callers to declared names.
+ */
+export interface IndexNamesByTable {
+${y}
+}
+
+export type IndexName<T extends keyof DataModel> = IndexNamesByTable[T];
+
+/** Per-table search-index name union. \`never\` for tables without searchIndex. */
+export interface SearchIndexNamesByTable {
+${x}
+}
+
+export type SearchIndexName<T extends keyof DataModel> = SearchIndexNamesByTable[T];
+
+/** Per-table rank-index name union. \`never\` for tables without a rankIndex. */
+export interface RankIndexNamesByTable {
+${b}
+}
+
+export type RankIndexName<T extends keyof DataModel> = RankIndexNamesByTable[T];
+
+/** Per-table geo-index name union. \`never\` for tables without a geoIndex. */
+export interface GeoIndexNamesByTable {
+${f}
+}
+
+export type GeoIndexName<T extends keyof DataModel> = GeoIndexNamesByTable[T];
+
+/** Union of declared vector index names. \`never\` when none are declared. */
+export type VectorIndexName = ${T};
+
+${$}
+
+/** Per-table insert shape, accepted by \`ctx.db.<table>.insert(...)\`. */
+export interface InsertModel {
+${u}
+}
+
+export type Insert<T extends keyof DataModel> = InsertModel[T];
+
+/**
+ * Phantom relation descriptors. They carry the relation kind and target table
+ * as type parameters only — there is no runtime value — so the \`with\` argument
+ * and its return type can be inferred from {@link Relations}.
+ */
+export interface OneRelation<Target extends keyof DataModel, Field extends string> {
+    readonly __field: Field;
+    readonly __relationKind: "one";
+    readonly __target: Target;
+}
+
+export interface ManyRelation<Target extends keyof DataModel> {
+    readonly __relationKind: "many";
+    readonly __target: Target;
+}
+
+/** Per-table relation map keyed by accessor name. \`{}\` for tables with none. */
+export interface Relations {
+${I}
+}
+
+`,_)};export{_ as SCHEMA_MODULE_PATH,w as emitDataModel};

package/dist/packem_shared/emitDrizzleSchema-bct1OuH5.mjs

@@ -0,0 +1,15 @@
+import{SCHEMA_MODULE_PATH as c}from"./emitDataModel-CuFqq97x.mjs";import{r as m}from"./qualifiers-Bl5fSmav.mjs";import{G as b,a as z,d as T,v as f,u as A,g as x,c as h}from"./shared-8vTRkL2-.mjs";const d=e=>{switch(e.kind){case"array":case"object":case"record":case"union":return{builder:"text",mode:"json",notNull:!0,typeAnnotation:f(e)};case"bigint":return{builder:"blob",mode:"bigint",notNull:!0};case"boolean":return{builder:"integer",mode:"boolean",notNull:!0};case"bytes":return{builder:"blob",mode:"buffer",notNull:!0};case"date":case"timestamp":return{builder:"integer",notNull:!0};case"from":return{builder:"text",notNull:!0,typeAnnotation:f(e)};case"id":return{builder:"text",notNull:!0};case"literal":{const t=e.literalValue??"";return t.startsWith('"')||t.startsWith("'")?{builder:"text",notNull:!0}:t==="true"||t==="false"?{builder:"integer",mode:"boolean",notNull:!0}:t==="null"?{builder:"text",notNull:!0}:{builder:"real",notNull:!0}}case"null":return{builder:"text",notNull:!0};case"number":return{builder:"real",notNull:!0};case"optional":return{...e.inner?d(e.inner):{builder:"text",notNull:!1},notNull:!1};case"storage":case"string":return{builder:"text",notNull:!0};default:return{builder:"text",notNull:!0}}},N=(e,t)=>{const r=A(e);return r.kind==="id"&&r.tableName!==void 0&&t.has(r.tableName)?r.tableName:void 0},j=(e,t,r)=>{x(e,"drizzle column name");const n=d(t),o=n.mode?`, { mode: "${n.mode}" }`:"";let l=`${n.builder}("${e}"${o})`;n.typeAnnotation&&(l+=`.$type<${n.typeAnnotation}>()`);const s=N(t,r);return s!==void 0&&(l+=`.references((): AnySQLiteColumn => ${s}._id)`),n.notNull&&t.column?.notNull!==!1&&(l+=".notNull()"),l},I=e=>{const t=e.unique?"uniqueIndex":"index",r=e.fields.map(n=>(x(n,"drizzle index field"),`t.${n}`)).join(", ");return`    ${h(e.name)}: ${t}(${JSON.stringify(e.name)}).on(${r}),`},S=(e,t)=>{z(e.name,"table name");const r=['    _id: text("_id").primaryKey(),','    _creationTime: integer("_creationTime").notNull(),',...Object.entries(e.shape).map(([o,l])=>`    ${o}: ${j(o,l,t)},`)].join(`
+`),n=e.indexes.length>0?`, (t) => ({
+${e.indexes.map(o=>I(o)).join(`
+`)}
+})`:"";return`export const ${e.name} = sqliteTable("${e.name}", {
+${r}
+}${n});`},C=e=>e.typeAnnotation?.includes('Id<"')??!1,D=(e,t)=>{const r=new Set(["integer","sqliteTable","text"]),n=new Set;let o=!1,l=!1;for(const s of e){for(const i of Object.values(s.shape)){const a=d(i);r.add(a.builder),l=l||C(a),o=o||N(i,t)!==void 0}for(const i of s.indexes)n.add(i.unique?"uniqueIndex":"index")}return{columns:[...r].toSorted((s,i)=>s.localeCompare(i)),indexes:[...n].toSorted((s,i)=>s.localeCompare(i)),needsAnyColumn:o,needsId:l}},p=(e,t=!1)=>{if(e.length===0)return`${b}export {};
+`;const r=T(t),n=new Set(e.map(u=>u.name)),{columns:o,indexes:l,needsAnyColumn:s,needsId:i}=D(e,n),a=[...l,...o].toSorted((u,g)=>u.localeCompare(g)),$=e.map(u=>S(u,n)).join(`
+
+`),y=[s?`import type { AnySQLiteColumn } from "${r.serverDrizzle}";
+`:"",i?`import type { Id } from "./dataModel.js";
+`:""].join("");return`${b}import { ${a.join(", ")} } from "${r.serverDrizzle}";
+${y}
+${$}
+`},v=(e,t=!1)=>{const r=e.tables.filter(o=>o.shardMode==="global"),n=e.tables.filter(o=>o.shardMode!=="global");return{global:m(p(r,t),c),shard:m(p(n,t),c)}};export{v as default};