@nxara/olio 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nxara contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,336 @@
-# Temporary Holding Version
+# @nxara/olio
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Modular, type-safe GraphQL applications. Each module owns its SDL, resolvers and middleware; `olio()` composes them into one executable `GraphQLSchema`. Every resolver and middleware key is checked against the `Application` type generated by [`@nxara/olio-codegen`](../codegen).
+
+## Install
+
+```sh
+bun add @nxara/olio graphql@16
+bun add -d @nxara/olio-codegen
+```
+
+`graphql` 16 is a peer dependency (not 17, which is about 4× slower on small queries).
+
+## Register your app
+
+```ts
+// src/olio.d.ts
+import type { Application } from "./generated.js";
+
+declare module "@nxara/olio" {
+  interface Olio {
+    application: Application;
+    ctx: { req_id: string; userId?: string };
+    // Optional: subscriptions' own context. Leave it out and they get ctx.
+    sub_ctx: { connectionId: string; userId?: string };
+  }
+}
+```
+
+## Modules
+
+```ts
+// src/modules/users/index.ts
+import { module, mw } from "@nxara/olio";
+import { loadResolvers, loadTypeDefs } from "@nxara/olio-tools";
+
+export const usersModule = module.users({
+  typeDefs: await loadTypeDefs(new URL("typedefs/*.gql", import.meta.url)),
+  resolvers: await loadResolvers(
+    new URL("{query,mutation,subscription}.{js,ts}", import.meta.url),
+    new URL("resolvers/*.{js,ts}", import.meta.url)
+  ),
+  middleware: mw.users({ Query: { user: [cache()] } })
+});
+```
+
+Resolver files export one object per type, built with a typed helper:
+
+```ts
+// query.ts
+export const Query = query.users({
+  user: (root, { id }, ctx, info) => findUser(id)
+});
+
+// resolvers/user.ts
+export const User = resolvers.users.User({
+  name: (user, { trim }) => user.name
+});
+```
+
+`mutation.<id>` and `subscription.<id>` work the same way. See [Subscriptions](#subscriptions) for what a subscription field looks like.
+
+Or write the map inline, with no builders: it's typed from the module just the same.
+
+```ts
+export const usersModule = module.users({
+  typeDefs,
+  resolvers: {
+    Query: { user: (root, { id }) => findUser(id) }, // id: string
+    User: { name: (user) => user.name }, // user: what User maps to
+    DateTime: DateTimeResolver // a scalar this module defines
+  },
+  enums: { Role: { ADMIN: 1, GUEST: 2 } } // internal values, see below
+});
+```
+
+Unknown types and fields, other modules' fields and wrong return types are compile errors, reported at the field. `resolvers` is one map: inline like this, or what `loadResolvers` returns, which passes through unchecked since each file was typed where it was written. A scalar's implementation comes from the module whose SDL defines it, and only from that module.
+
+## Features: splitting a large module
+
+When a module grows, split it into features: subfolders that each own part of the module's schema.
+
+```
+src/modules/sales/
+├── index.ts              # the module: module-wide middleware, loads its features
+├── store.ts              # shared code
+├── typedefs/             # SDL the module itself owns (optional)
+├── customers/            # feature "customers"
+│   ├── index.ts
+│   ├── typedefs/customers.gql
+│   ├── query.ts  mutation.ts  middleware.ts
+└── orders/               # feature "orders"
+    ├── index.ts
+    ├── typedefs/orders.gql
+    └── query.ts  mutation.ts  middleware.ts
+```
+
+```ts
+// sales/orders/index.ts
+export const orders = feature.sales.orders({
+  typeDefs: await loadTypeDefs(new URL("typedefs/*.gql", import.meta.url)),
+  resolvers: await loadResolvers(
+    new URL("{query,mutation}.{js,ts}", import.meta.url)
+  ),
+  middleware: mw.sales.orders({
+    Mutation: { cancelOrder: [requireRole("MANAGER")] }
+  })
+});
+
+// sales/index.ts
+export const salesModule = module.sales({
+  middleware: mw.sales({ Mutation: { "*": [journal()] } }), // every feature's fields
+  features: await loadFeatures(new URL("*/index.{js,ts}", import.meta.url))
+});
+```
+
+- **Discovery.** Codegen treats a direct subfolder of a module as a feature when the `typeDefs` glob finds files of its own there. With `**/typedefs/**/*.gql`, `sales/orders/typedefs/` makes `orders` a feature, while `sales/typedefs/` stays the module's own SDL. Features don't nest: deeper folders belong to their feature.
+- **Isolation.** A feature owns the fields its SDL declares, like a module does, and only it can resolve them. To add a field to a sibling's type, `extend` it (`orders` adds `Customer.orders`).
+- **Builders.** Each feature has its own typed builders: `query.sales.orders`, `mutation.sales.orders`, `resolvers.sales.orders.SalesOrder`, `mw.sales.orders`. The module's are still there (`query.sales` for fields the module itself declares).
+- **Middleware nests.** For a feature's field, the chain runs app → module → feature. `mw.sales` reaches every feature's fields, and `mw.sales.orders` only orders'.
+- **Names.** A feature folder can't share its name with a type the module declares, or with a function property (`name`, `length`, …), because both sit side by side in the builders. Codegen tells you if one does.
+
+## Application
+
+```ts
+import { mw, olio } from "@nxara/olio";
+
+const middleware = mw({
+  "*": { "*": [requestLogger()] },
+  Mutation: { "*": [requireAuth()] }
+});
+
+export const app = olio({
+  middleware,
+  modules: await loadModules(
+    new URL("modules/*/index.{js,ts}", import.meta.url)
+  ), // from @nxara/olio-tools
+  directives // the same list codegen uses; required once codegen had some
+});
+// app.schema → any GraphQL server (graphql-http, Yoga, Apollo, …)
+```
+
+You can also list modules yourself: `modules: [usersModule, authModule]`.
+
+`olio()` composes the modules' SDL through `@nxara/olio-schema` and checks the result before returning:
+
+- **Root types come for free.** Modules `extend type Query` (or `Mutation`); nobody needs a placeholder `type Query { _empty: String }`. That also means a module that only extends root types can be tested alone: `olio({ modules: [usersModule] })`. One that uses another module's types takes that module too: `olio({ modules: [catalog, reviews] })`.
+- **A module resolves only what it declares.** It owns the fields in its own definitions and `extend`s, and the defining module owns `__isTypeOf` / `__resolveType`. Resolving another module's field throws: `Module "posts": "User.name" is declared by module "users"; only that module can resolve it`. With codegen, the same message is the compile error, on the field: `Type '(row) => …' is not assignable to type '"User.name is declared by module users; only that module can resolve it"'`.
+- **Errors point at files.** SDL and schema errors are reported as `file:line:column: message`.
+
+## Middleware
+
+```ts
+const requireAuth =
+  (): MiddlewareFn =>
+  ({ root, args, ctx, info }, next) => {
+    if (!ctx.userId) throw new Error("Unauthorized");
+    return next();
+  };
+```
+
+Written inline under a field key, in `mw.<id>()` or a module's `middleware`, a middleware gets that field's types: `root` is its parent (the mapper, if any) and `args` its arguments, so `mw.users({ User: { email: [({ root }, next) => …] } })` sees the `User` row. Root types have `root: undefined`, and `"*"` keys stay loose since they span fields. A middleware written on its own, like `requireAuth`, is typed `MiddlewareFn`: `root: unknown` and `args: Record<string, unknown>`, so it fits any key.
+
+Middleware is nested, `{ Type: { field | "*": [...] } }`. For each resolver the chain runs top-down:
+
+1. app `*.*`
+2. app `Type.*`
+3. app `Type.field`
+4. module `Type.*`
+5. module `Type.field`
+6. feature `Type.*` (for a feature's field)
+7. feature `Type.field`
+
+The application addresses root types only, under whatever names the schema gives them: with `schema { query: RootQuery }` you write `mw({ RootQuery: { … } })` and `export const RootQuery = query.users({ … })`. A module addresses the fields it and its features declare, including fields they add to other modules' types with `extend`; a feature, only its own.
+
+### Skipping middleware: `@bypass`
+
+A field tells its middleware what to skip with `@bypass` in the SDL, and each middleware decides for itself:
+
+```graphql
+extend type Query {
+  me: Employee @bypass(keys: "auth")
+}
+
+# On a type, or an extend block: every field declared in that block.
+extend type Mutation @bypass(keys: ["auth", "audit"]) {
+  login(email: String!, password: String!): LoginResult!
+}
+```
+
+```ts
+const requireAuth =
+  (): MiddlewareFn =>
+  ({ ctx, bypass }, next) => {
+    if (!ctx.userId && !bypass.has("auth")) throw unauthenticated();
+    return next();
+  };
+```
+
+- **Per field, never per request.** `bypass` holds the keys of the field being resolved, so marking `login` doesn't relax anything else in the same operation.
+- **Where it goes:** on a field of an object type, or on an object type (definition or `extend`), where it covers the fields declared in that block. A block in one module doesn't reach another module's fields on the same type. Anywhere else is an error with its location.
+- **Out of the schema.** olio and codegen read and remove it while composing, so it isn't in the served schema, `schema.gql` or introspection. You don't need to declare it; `bypassDefinition` from `@nxara/olio-schema` is its SDL, for editor tooling. `@copy` doesn't carry it to copied fields.
+- **Typed.** With codegen, `bypass` is a `ReadonlySet` of the keys used anywhere in the SDL (`BypassKey`), so `bypass.has("auht")` is a compile error. Untyped, it's a set of strings.
+- **Nothing is dropped for you.** Other middleware, such as a logger, keeps running on a field marked `@bypass(keys: "auth")`.
+
+Middleware wraps the resolvers modules define, and any field it names explicitly. `"*"` keys only reach fields with a resolver, but naming a field (`User: { email: [redact()] }`) wraps GraphQL's default resolver when the field has none, so the middleware always runs.
+
+Every key is checked when `olio()` builds the schema, even without codegen. A key that matches no field, or an application key on a non-root type, throws.
+
+## Subscriptions
+
+A subscription field is a function that returns an async iterable of the field's values. Return the event source's own iterator, filtered at the source:
+
+```ts
+export const Subscription = subscription.users({
+  userUpdated: (_root, { id }, ctx) =>
+    ctx.pubsub.subscribe("user:updated", (row) => row._id === id)
+});
+```
+
+An async generator works too, for mapping events (`async *userUpdated() { for await (const row of …) yield … }`), with one catch: while it waits inside `for await`, it can only be ended at its next event. graphql-ws waits for that before running `onComplete` and `onClose`, so a client that leaves while nothing happens isn't cleaned up until something does. A source whose `return()` ends it at once (like [`apps/example-server/src/pubsub.ts`](../../apps/example-server/src/pubsub.ts)'s) doesn't have that problem.
+
+- **Each yielded value is the field's value**, checked against the field type (with [mappers](#mappers) applied). Nested field resolvers run for every event.
+- **Middleware runs once**, when a client subscribes, which is the place for auth and logging. Per-event logic belongs in the iterator.
+- **Context:** subscription resolvers and `Subscription` middleware get `sub_ctx`, and `"*"` middleware can run on either kind: type it `MiddlewareFn<Context | SubscriptionContext>`. Without a separate `sub_ctx`, both are just `ctx`.
+- **The event source is yours** (in-memory, Redis, …). [`apps/example-server/src/pubsub.ts`](../../apps/example-server/src/pubsub.ts) has a small typed in-memory one. To serve them, run graphql-ws or graphql-sse with `app.schema`: `@nxara/olio-http`'s README has the setup.
+
+## Field extensions
+
+A field's value can also be an object, `{ resolve?, extensions? }`, to attach `extensions` to the schema field. Tools read them from there: graphql-query-complexity's `complexity`, Grafast's plans, or your own middleware through `info.parentType.getFields()[info.fieldName].extensions`. Read back there, registered keys keep their types (`complexity` is a number, or a function of `{ args, childComplexity }`); graphql's index signature still lets any other key through as `unknown`.
+
+```ts
+export const Query = query.inventory({
+  products: {
+    resolve: (_root, { filter }) => listProducts(filter),
+    extensions: {
+      complexity: ({ args, childComplexity }) =>
+        (args.filter?.pageSize ?? 20) * childComplexity
+    }
+  }
+});
+resolvers.users.User({ email: { extensions: { roles: ["ADMIN"] } } }); // no resolve: the default resolver stays
+```
+
+Extensions are typed: register what they may hold, and anything else is a compile error. `Source` and `Args` are the field's parent and arguments, for extensions that are functions:
+
+```ts
+declare module "@nxara/olio" {
+  interface FieldExtensions<Source, Args> {
+    // graphql-query-complexity's shape: the field's args and its selection's cost
+    complexity?:
+      | number
+      | ((estimate: { args: Args; childComplexity: number }) => number);
+    roles?: Role[];
+  }
+}
+```
+
+Keys a library adds to graphql's own `GraphQLFieldExtensions` count too. Middleware still wraps `resolve`. Subscription fields take the same form, with the async generator as `resolve`. At runtime the object may hold only `resolve` and `extensions`. Without codegen, extensions are a plain `Record<string, unknown>`.
+
+## Mappers
+
+By default a resolver returns the generated type: a `User` resolver must return a full `User`. To return what you store instead and let field resolvers fill in the rest, register a mapper:
+
+```ts
+declare module "@nxara/olio" {
+  interface Olio {
+    application: Application;
+    mappers: { User: UserRow };
+  }
+}
+```
+
+Then every resolver that returns a `User` returns a `UserRow`. That holds through lists, nulls, unions, and the fields of other types, so `UserPage.data` takes rows too. `User` field resolvers also receive the row as `root`.
+
+Mappers work for object types and interfaces, keyed by GraphQL type name:
+
+- **An interface with a mapper** (`mappers: { Node: NodeRow }`): fields returning it return a `NodeRow`, and `__resolveType` receives one.
+- **An interface without a mapper**: fields returning it return any implementer, each as its own mapper (`UserRow | Post`), because that is what graphql resolves. `__resolveType` receives the same union.
+- **Unions** map member by member.
+
+Enums with internal values are configured in codegen (`CustomEnums`) rather than here, because they also change argument and input types. See the codegen README. The values go in the owning module's (or feature's) `enums` option, never in `resolvers`; once `CustomEnums` registers an enum, `enums` is required, so they can't be forgotten. `resolvers.<id>.<Enum>({ ... })` types a map kept in its own file, and `loadEnums` from `@nxara/olio-tools` loads such files (unchecked, like `loadResolvers`). In an untyped app nothing knows values were expected, so a resolver returning an internal value no module mapped fails with `Enum "Role" cannot represent value: 1. No module gave "Role" internal values: ...`.
+
+## Field types
+
+Resolvers built with the builders are typed for you. For code outside them, such as services, loaders and tests, take the types from `generated.ts` and olio:
+
+```ts
+import type { Fields } from "@nxara/olio";
+
+import type { LoginInput, Role, Scalars, User } from "./generated.js";
+
+type UserArgs = Fields["Query"]["user"]["args"]; // { id: string }
+type UserResult = Fields["Query"]["user"]["result"]; // User | null (UserRow | null with mappers)
+type NameArgs = Fields["User"]["name"]["args"]; // { trim?: boolean | null }
+type When = Scalars["DateTime"]["input"]; // a scalar, by direction
+```
+
+- Object, input, enum, union and interface types are exported by name from `generated.ts`.
+- `Fields` covers every field a module declares, whichever module that is. It's plain indexed access, so your editor completes the type, then the field, then `args` / `result`.
+- `result` is what the resolver returns, so with [mappers](#mappers) it's the mapped type.
+- An argument with an SDL default (`limit: Int = 10`) is a required key typed `Maybe<T>`: graphql fills in the default before the resolver runs, but a client can still send `null`. A service called from elsewhere takes its own parameter type, e.g. `{ term: string; limit?: number | null }`.
+
+## Without codegen or tools
+
+Olio needs neither `@nxara/olio-codegen` nor `@nxara/olio-tools`. Write SDL as strings, resolvers as plain maps keyed by type, and build modules with `createModule` / `createFeature`. Everything works the same at runtime (middleware layers, features, enum values, subscriptions), only with looser types:
+
+```ts
+import { createFeature, createModule, mw, olio } from "@nxara/olio";
+
+const users = createModule("users", {
+  typeDefs:
+    "type User { id: ID! name: String! } extend type Query { user(id: ID!): User }",
+  // root: unknown, args: Record<string, unknown>, ctx: your registered ctx
+  resolvers: {
+    Query: { user: (_root, args) => ({ id: String(args.id), name: "Ada" }) }
+  },
+  middleware: { Query: { "*": [audit()] } },
+  features: [
+    createFeature("users", "admin", {
+      typeDefs: "extend type Mutation { ban(id: ID!): Boolean! }",
+      resolvers: { Mutation: { ban: () => true } }
+    })
+  ]
+});
+
+export const app = olio({
+  middleware: mw({ Query: { "*": [requireAuth()] } }),
+  modules: [users]
+});
+```
+
+- Use `createModule(id, config)` and `createFeature(module, id, config)`. Without an `Application` there are no known ids, so `module.<id>`, `query.<id>` and friends have nothing to check against.
+- Key resolver maps by type: `{ Query: { user } }`. The builders (`query.users({ user })`) return the _inner_ map, so wrap them the same way: `{ Query: query.users({ user }) }`. `loadResolvers` does this for you, using export names.
+- You can still register `ctx` (and `sub_ctx`) on their own, so middleware and resolvers get a typed context.
+- To get the fully typed builders without running codegen, write the `Application` type by hand. It's a plain type: per module (and `"module/feature"`), each type's `{ type; fields; args? }`, root types with `root: "query" | "mutation" | "subscription"`, abstract types with `resolveType`, enums with `fields: never; enum: "A" | "B"`. Codegen's README shows the format.

package/dist/builders.d.ts

@@ -0,0 +1,14 @@
+import type { FeatureConfig, FeatureId, FeatureMiddleware, Middleware, ModuleConfig, ModuleId, ModuleMiddleware, ModuleTypeName, MutationResolvers, OlioFeature, OlioModule, QueryResolvers, SubscriptionResolvers, TypeResolvers } from "./types.js";
+type Builder<T> = (value: T) => T;
+export declare const module: { [M in ModuleId]: (config: ModuleConfig<M>) => OlioModule; };
+export declare const feature: { [M in ModuleId]: { [F in FeatureId<M>]: (config: FeatureConfig<M, F>) => OlioFeature; }; };
+export declare const mw: Builder<Middleware> & { [M in ModuleId]: Builder<ModuleMiddleware<M>> & { [F in FeatureId<M>]: Builder<FeatureMiddleware<M, F>>; }; };
+export declare const query: { [M in ModuleId]: Builder<QueryResolvers<M>> & { [F in FeatureId<M>]: Builder<QueryResolvers<`${M}/${F}`>>; }; };
+export declare const mutation: { [M in ModuleId]: Builder<MutationResolvers<M>> & { [F in FeatureId<M>]: Builder<MutationResolvers<`${M}/${F}`>>; }; };
+export declare const subscription: { [M in ModuleId]: Builder<SubscriptionResolvers<M>> & { [F in FeatureId<M>]: Builder<SubscriptionResolvers<`${M}/${F}`>>; }; };
+type TypeBuilders<O extends string> = {
+    [T in ModuleTypeName<O>]: Builder<TypeResolvers<O, T>>;
+};
+export declare const resolvers: { [M in ModuleId]: TypeBuilders<M> & { [F in FeatureId<M>]: TypeBuilders<`${M}/${F}`>; }; };
+export {};
+//# sourceMappingURL=builders.d.ts.map

package/dist/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../src/builders.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,cAAc,EACd,qBAAqB,EACrB,aAAa,EACd,MAAM,YAAY,CAAC;AAkBpB,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AAElC,eAAO,MAAM,MAAM,EAGd,GACF,CAAC,IAAI,QAAQ,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,UAAU,GACzD,CAAC;AAEF,eAAO,MAAM,OAAO,EAKf,GACF,CAAC,IAAI,QAAQ,GAAG,GACd,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,GAClE,GACF,CAAC;AAEF,eAAO,MAAM,EAAE,EAEE,OAAO,CAAC,UAAU,CAAC,GAAG,GACpC,CAAC,IAAI,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAAG,GAC7C,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACtD,GACF,CAAC;AAEF,eAAO,MAAM,KAAK,EAAyC,GACxD,CAAC,IAAI,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,GAC3C,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAC1D,GACF,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAyC,GAC3D,CAAC,IAAI,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAAG,GAC9C,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAC7D,GACF,CAAC;AAEF,eAAO,MAAM,YAAY,EAAyC,GAC/D,CAAC,IAAI,QAAQ,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,GAAG,GAClD,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GACjE,GACF,CAAC;AAEF,KAAK,YAAY,CAAC,CAAC,SAAS,MAAM,IAAI;KACnC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACvD,CAAC;AAEF,eAAO,MAAM,SAAS,EAEN,GACb,CAAC,IAAI,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,GAChC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,GAC/C,GACF,CAAC"}

package/dist/builders.js

@@ -0,0 +1,18 @@
+import { createFeature, createModule } from "./olio.js";
+function perModule(make) {
+    return new Proxy({}, {
+        get: (_target, id) => make(String(id))
+    });
+}
+const identity = (value) => value;
+const nested = new Proxy(identity, { get: () => identity });
+export const module = perModule((id) => (config) => createModule(id, config));
+export const feature = perModule((m) => perModule((f) => (config) => createFeature(m, f, config)));
+export const mw = new Proxy(identity, {
+    get: () => nested
+});
+export const query = perModule(() => nested);
+export const mutation = perModule(() => nested);
+export const subscription = perModule(() => nested);
+export const resolvers = perModule(() => perModule(() => nested));
+//# sourceMappingURL=builders.js.map

package/dist/builders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.js","sourceRoot":"","sources":["../src/builders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAsBxD,SAAS,SAAS,CAAI,IAAuB;IAC3C,OAAO,IAAI,KAAK,CAAC,EAAuB,EAAE;QACxC,GAAG,EAAE,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;KACvC,CAAC,CAAC;AACL,CAAC;AAGD,MAAM,QAAQ,GAAG,CAAI,KAAQ,EAAK,EAAE,CAAC,KAAK,CAAC;AAG3C,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;AAI5D,MAAM,CAAC,MAAM,MAAM,GAAG,SAAS,CAC7B,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAA8B,EAAE,EAAE,CACzC,YAAY,CAAC,EAAc,EAAE,MAAM,CAAC,CAGvC,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CACrC,SAAS,CACP,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,MAAuC,EAAE,EAAE,CACjD,aAAa,CAAC,CAAa,EAAE,CAAC,EAAE,MAAM,CAAC,CAC1C,CAKF,CAAC;AAEF,MAAM,CAAC,MAAM,EAAE,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE;IACpC,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM;CAClB,CAIA,CAAC;AAEF,MAAM,CAAC,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC,MAAM,CAI1C,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC,MAAM,CAI7C,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC,MAAM,CAIjD,CAAC;AAMF,MAAM,CAAC,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,EAAE,CACtC,SAAS,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAKxB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { feature, module, mutation, mw, query, resolvers, subscription } from "./builders.js";
+export { createFeature, createModule, olio } from "./olio.js";
+export type { OlioApp, OlioConfig } from "./olio.js";
+export type { Context, FeatureConfig, BypassKey, DirectiveName, FeatureId, FeatureMiddleware, FieldExtensions, FieldResolver, Fields, LoadedEnums, LoadedResolvers, Middleware, MiddlewareFn, MiddlewareMap, MiddlewareParams, ModuleConfig, ModuleId, ModuleMiddleware, ModuleTypeName, MutationResolvers, Olio, OlioFeature, OlioModule, OwnerResolvers, QueryResolvers, ResolverMap, SubscriptionContext, SubscriptionResolvers, TypeResolvers, TypeSource } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACN,QAAQ,EACR,EAAE,EACF,KAAK,EACL,SAAS,EACT,YAAY,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC9D,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACrD,YAAY,EACV,OAAO,EACP,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,MAAM,EACN,WAAW,EACX,eAAe,EACf,UAAU,EACV,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,UAAU,EACV,cAAc,EACd,cAAc,EACd,WAAW,EACX,mBAAmB,EACnB,qBAAqB,EACrB,aAAa,EACb,UAAU,EACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { feature, module, mutation, mw, query, resolvers, subscription } from "./builders.js";
+export { createFeature, createModule, olio } from "./olio.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACN,QAAQ,EACR,EAAE,EACF,KAAK,EACL,SAAS,EACT,YAAY,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC"}

package/dist/olio.d.ts

@@ -0,0 +1,21 @@
+import { type SchemaDirective } from "@nxara/olio-schema";
+import { type GraphQLSchema } from "graphql";
+import type { FeatureConfig, DirectiveName, Middleware, ModuleConfig, ModuleId, OlioFeature, OlioModule } from "./types.js";
+type DirectivesOption = [DirectiveName] extends [never] ? {
+    directives?: readonly SchemaDirective[];
+} : {
+    directives: readonly SchemaDirective<DirectiveName>[];
+};
+export type OlioConfig = {
+    modules: readonly OlioModule[];
+    middleware?: Middleware;
+} & DirectivesOption;
+export interface OlioApp {
+    readonly schema: GraphQLSchema;
+    readonly modules: readonly OlioModule[];
+}
+export declare function createModule<M extends ModuleId>(id: M, config: ModuleConfig<M>): OlioModule;
+export declare function createFeature<M extends ModuleId, F extends string>(module: M, id: F, config: FeatureConfig<M, F>): OlioFeature;
+export declare function olio(config: OlioConfig): OlioApp;
+export {};
+//# sourceMappingURL=olio.d.ts.map

package/dist/olio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"olio.d.ts","sourceRoot":"","sources":["../src/olio.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAqBL,KAAK,aAAa,EACnB,MAAM,SAAS,CAAC;AAMjB,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EAEb,UAAU,EAIV,YAAY,EACZ,QAAQ,EAER,WAAW,EACX,UAAU,EAGX,MAAM,YAAY,CAAC;AAIpB,KAAK,gBAAgB,GAAG,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,GACnD;IAEE,UAAU,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CACzC,GACD;IAEE,UAAU,EAAE,SAAS,eAAe,CAAC,aAAa,CAAC,EAAE,CAAC;CACvD,CAAC;AAEN,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,GAAG,gBAAgB,CAAC;AAErB,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CACzC;AAsED,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAC7C,EAAE,EAAE,CAAC,EACL,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GACtB,UAAU,CAUZ;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,MAAM,EAChE,MAAM,EAAE,CAAC,EACT,EAAE,EAAE,CAAC,EACL,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAC1B,WAAW,CAUb;AAmnBD,wBAAgB,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAoBhD"}