@leodamours/jsonapi-dsl 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Léo Damours
+
+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

@@ -0,0 +1,149 @@
+# @leodamours/jsonapi-dsl
+
+[![CI](https://github.com/LeoDamours/json-api-client/actions/workflows/ci.yml/badge.svg)](https://github.com/LeoDamours/json-api-client/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@leodamours/jsonapi-dsl)](https://www.npmjs.com/package/@leodamours/jsonapi-dsl)
+
+A TypeScript-first DSL for [JSON:API](https://jsonapi.org/) — define resources once, infer every type.
+
+Zero dependencies. Zero runtime overhead beyond tiny marker objects.
+
+## Install
+
+```bash
+npm install @leodamours/jsonapi-dsl
+```
+
+## Quick Start
+
+```ts
+import { defineResource, t, hasOne, hasMany } from "@leodamours/jsonapi-dsl";
+import type { InferResource, JsonApiDocument } from "@leodamours/jsonapi-dsl";
+
+const User = defineResource("users", {
+  name: t.string(),
+  email: t.string(),
+  age: t.nullable(t.number()),
+});
+
+const Post = defineResource(
+  "posts",
+  {
+    title: t.string(),
+    body: t.string(),
+    publishedAt: t.nullable(t.date()),
+    tags: t.array(t.string()),
+  },
+  {
+    author: hasOne("users"),
+    comments: hasMany("comments"),
+  }
+);
+
+// Full resource type inferred from definition
+type PostResource = InferResource<typeof Post>;
+
+// Use in API response typing
+type PostDocument = JsonApiDocument<PostResource>;
+```
+
+## Type Builders
+
+| Builder | TypeScript type | Example |
+|---------|----------------|---------|
+| `t.string()` | `string` | `name: t.string()` |
+| `t.number()` | `number` | `age: t.number()` |
+| `t.boolean()` | `boolean` | `active: t.boolean()` |
+| `t.date()` | `Date` | `createdAt: t.date()` |
+| `t.nullable(inner)` | `T \| null` | `bio: t.nullable(t.string())` |
+| `t.array(inner)` | `T[]` | `tags: t.array(t.string())` |
+| `t.optional(inner)` | `T \| undefined` | `nickname: t.optional(t.string())` |
+
+Builders compose — `t.nullable(t.array(t.string()))` infers as `string[] | null`.
+
+## Relationships
+
+```ts
+import { hasOne, hasMany } from "@leodamours/jsonapi-dsl";
+
+const Article = defineResource(
+  "articles",
+  { title: t.string() },
+  {
+    author: hasOne("users"),       // { data: { type: "users"; id: string } | null }
+    comments: hasMany("comments"), // { data: { type: "comments"; id: string }[] }
+  }
+);
+```
+
+Relationship types enforce literal type strings — `hasOne("users")` won't accept `{ type: "people" }`.
+
+## Per-Verb Attribute Narrowing
+
+Control which attributes are writable for create vs update:
+
+```ts
+const Author = defineResource(
+  "authors",
+  {
+    name: t.string(),
+    email: t.string(),
+    createdAt: t.string(), // read-only, set by server
+  },
+  {
+    posts: hasMany("posts"),
+  },
+  {
+    create: ["name", "email"] as const,  // createdAt excluded from create
+    update: ["name"] as const,           // only name editable on update
+  }
+);
+```
+
+When no options are provided, all attributes are writable (backward compatible).
+
+This narrowing is consumed by `@leodamours/jsonapi-client`'s `CreatePayload` and `UpdatePayload` types.
+
+## Inference Utilities
+
+```ts
+import type {
+  InferResource,
+  InferResourceAttributes,
+  InferResourceRelationships,
+  InferResourceType,
+  InferType,
+  InferAttributes,
+} from "@leodamours/jsonapi-dsl";
+
+type PostResource = InferResource<typeof Post>;
+// { type: "posts"; id?: string; attributes: { title: string; ... }; relationships: { ... } }
+
+type PostAttrs = InferResourceAttributes<typeof Post>;
+// { title: string; body: string; publishedAt: Date | null; tags: string[] }
+
+type PostRels = InferResourceRelationships<typeof Post>;
+// { author: JsonApiRelationship & { data: { type: "users"; id: string } | null }; ... }
+
+type PostType = InferResourceType<typeof Post>;
+// "posts"
+```
+
+## JSON:API Core Types
+
+The package also exports all standard JSON:API types:
+
+```ts
+import type {
+  JsonApiResource,
+  JsonApiDocument,
+  JsonApiCollectionDocument,
+  JsonApiErrorDocument,
+  JsonApiRelationship,
+  JsonApiLinks,
+  JsonApiMeta,
+} from "@leodamours/jsonapi-dsl";
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,264 @@
+/**
+ * Core JSON:API specification types
+ * @see https://jsonapi.org/format/
+ */
+interface JsonApiResourceIdentifier {
+    type: string;
+    id: string;
+}
+interface JsonApiLinks {
+    self?: string;
+    related?: string;
+    [key: string]: string | undefined;
+}
+type JsonApiMeta = Record<string, unknown>;
+interface JsonApiRelationship {
+    data?: JsonApiResourceIdentifier | JsonApiResourceIdentifier[] | null;
+    links?: JsonApiLinks;
+    meta?: JsonApiMeta;
+}
+interface JsonApiRelationships {
+    [key: string]: JsonApiRelationship;
+}
+interface JsonApiResource<Attr extends Record<string, unknown> = Record<string, unknown>, Rel extends JsonApiRelationships = JsonApiRelationships> {
+    type: string;
+    id?: string;
+    attributes?: Attr;
+    relationships?: Rel;
+    links?: JsonApiLinks;
+    meta?: JsonApiMeta;
+}
+interface JsonApiError {
+    id?: string;
+    status?: string;
+    code?: string;
+    title?: string;
+    detail?: string;
+    source?: {
+        pointer?: string;
+        parameter?: string;
+        header?: string;
+    };
+    meta?: JsonApiMeta;
+}
+interface JsonApiDocumentLinks extends JsonApiLinks {
+    first?: string;
+    last?: string;
+    prev?: string;
+    next?: string;
+}
+interface JsonApiDocumentBase {
+    links?: JsonApiDocumentLinks;
+    meta?: JsonApiMeta;
+    jsonapi?: {
+        version?: string;
+        meta?: JsonApiMeta;
+    };
+}
+
+interface JsonApiDocument<T = JsonApiResource> extends JsonApiDocumentBase {
+    data: T;
+    included?: JsonApiResource[];
+}
+interface JsonApiCollectionDocument<T = JsonApiResource> extends JsonApiDocumentBase {
+    data: T[];
+    included?: JsonApiResource[];
+}
+interface JsonApiErrorDocument extends JsonApiDocumentBase {
+    errors: JsonApiError[];
+}
+interface JsonApiEmptyDocument extends JsonApiDocumentBase {
+    data: null;
+}
+type JsonApiResponseDocument<T = JsonApiResource> = JsonApiDocument<T> | JsonApiCollectionDocument<T> | JsonApiErrorDocument | JsonApiEmptyDocument;
+
+/**
+ * Type builder markers and the `t` namespace
+ *
+ * Each builder is a lightweight runtime object whose TypeScript type
+ * drives compile-time inference via InferType<T>.
+ */
+interface StringType {
+    readonly _type: "string";
+}
+interface NumberType {
+    readonly _type: "number";
+}
+interface BooleanType {
+    readonly _type: "boolean";
+}
+interface DateType {
+    readonly _type: "date";
+}
+interface NullableType<Inner extends TypeBuilder> {
+    readonly _type: "nullable";
+    readonly inner: Inner;
+}
+interface ArrayType<Inner extends TypeBuilder> {
+    readonly _type: "array";
+    readonly inner: Inner;
+}
+interface OptionalType<Inner extends TypeBuilder> {
+    readonly _type: "optional";
+    readonly inner: Inner;
+}
+type TypeBuilder = StringType | NumberType | BooleanType | DateType | NullableType<any> | ArrayType<any> | OptionalType<any>;
+type AttributesSchema = Record<string, TypeBuilder>;
+declare const t: {
+    string: () => StringType;
+    number: () => NumberType;
+    boolean: () => BooleanType;
+    date: () => DateType;
+    nullable: <T extends TypeBuilder>(inner: T) => NullableType<T>;
+    array: <T extends TypeBuilder>(inner: T) => ArrayType<T>;
+    optional: <T extends TypeBuilder>(inner: T) => OptionalType<T>;
+};
+
+/**
+ * Relationship definition helpers
+ */
+interface HasOneRelationship<T extends string = string> {
+    readonly _rel: "one";
+    readonly type: T;
+}
+interface HasManyRelationship<T extends string = string> {
+    readonly _rel: "many";
+    readonly type: T;
+}
+type RelationshipBuilder = HasOneRelationship | HasManyRelationship;
+type RelationshipsSchema = Record<string, RelationshipBuilder>;
+declare const hasOne: <T extends string>(type: T) => HasOneRelationship<T>;
+declare const hasMany: <T extends string>(type: T) => HasManyRelationship<T>;
+
+/**
+ * A resource definition that captures the type-level information
+ * needed for inference.
+ */
+interface ResourceDefinition<Type extends string = string, Attrs extends AttributesSchema = AttributesSchema, Rels extends RelationshipsSchema = RelationshipsSchema> {
+    readonly resourceType: Type;
+    readonly attributes: Attrs;
+    readonly relationships: Rels;
+    readonly createKeys?: readonly string[];
+    readonly updateKeys?: readonly string[];
+}
+/**
+ * Options for per-verb attribute narrowing.
+ * `create` lists which attribute keys are accepted by POST.
+ * `update` lists which attribute keys are accepted by PATCH.
+ */
+interface ResourceOptions<CK extends string = string, UK extends string = string> {
+    readonly create: readonly CK[];
+    readonly update: readonly UK[];
+}
+/** No relationships. */
+declare function defineResource<Type extends string, Attrs extends AttributesSchema>(type: Type, attributes: Attrs): ResourceDefinition<Type, Attrs, Record<string, never>>;
+/** With relationships. */
+declare function defineResource<Type extends string, Attrs extends AttributesSchema, Rels extends RelationshipsSchema>(type: Type, attributes: Attrs, relationships: Rels): ResourceDefinition<Type, Attrs, Rels>;
+/** With relationships + per-verb attribute options. */
+declare function defineResource<Type extends string, Attrs extends AttributesSchema, Rels extends RelationshipsSchema, CK extends keyof Attrs & string, UK extends keyof Attrs & string>(type: Type, attributes: Attrs, relationships: Rels, options: ResourceOptions<CK, UK>): ResourceDefinition<Type, Attrs, Rels> & {
+    readonly createKeys: readonly CK[];
+    readonly updateKeys: readonly UK[];
+};
+
+/**
+ * Leaf type map — resolves primitive builders in a single indexed access
+ * instead of chaining conditional types.
+ */
+interface LeafTypeMap {
+    string: string;
+    number: number;
+    boolean: boolean;
+    date: Date;
+}
+/**
+ * Resolve a leaf TypeBuilder (string/number/boolean/date) to its TS type.
+ */
+type InferLeaf<T extends TypeBuilder> = T extends {
+    readonly _type: infer K extends keyof LeafTypeMap;
+} ? LeafTypeMap[K] : never;
+/**
+ * Resolve one level of wrapper (nullable/array/optional around a leaf).
+ */
+type InferShallow<T extends TypeBuilder> = T extends NullableType<infer I extends TypeBuilder> ? InferLeaf<I> | null : T extends ArrayType<infer I extends TypeBuilder> ? InferLeaf<I>[] : T extends OptionalType<infer I extends TypeBuilder> ? InferLeaf<I> | undefined : InferLeaf<T>;
+/**
+ * Map a TypeBuilder marker to its corresponding TypeScript type.
+ *
+ * Non-recursive: handles up to 2 levels of nesting (e.g. optional(nullable(string))).
+ * This avoids TS2589 when consumed through compiled .d.ts files.
+ */
+type InferType<T extends TypeBuilder> = T extends NullableType<infer I extends TypeBuilder> ? InferShallow<I> | null : T extends ArrayType<infer I extends TypeBuilder> ? InferShallow<I>[] : T extends OptionalType<infer I extends TypeBuilder> ? InferShallow<I> | undefined : InferLeaf<T>;
+type OptionalKeys<Schema extends AttributesSchema> = {
+    [K in keyof Schema]: Schema[K] extends OptionalType<any> ? K : never;
+}[keyof Schema];
+type RequiredKeys<Schema extends AttributesSchema> = Exclude<keyof Schema, OptionalKeys<Schema>>;
+/**
+ * Map an attributes schema to a plain object type.
+ * Keys backed by `t.optional()` become truly optional properties.
+ */
+type InferAttributes<Schema extends AttributesSchema> = {
+    [K in RequiredKeys<Schema>]: InferType<Schema[K]>;
+} & {
+    [K in OptionalKeys<Schema>]?: InferType<Schema[K]>;
+};
+/**
+ * Simplified attribute inference without optional key splitting.
+ * All keys are required. Use this for payload types to reduce instantiation depth.
+ */
+type InferAttributesSimple<Schema extends AttributesSchema> = {
+    [K in keyof Schema]: InferType<Schema[K]>;
+};
+/**
+ * Indexed lookup for relationship shapes — avoids conditional types.
+ */
+interface RelationshipTypeMap<ResourceType extends string> {
+    one: JsonApiRelationship & {
+        data: {
+            type: ResourceType;
+            id: string;
+        } | null;
+    };
+    many: JsonApiRelationship & {
+        data: {
+            type: ResourceType;
+            id: string;
+        }[];
+    };
+}
+/**
+ * Map a single relationship builder to its JSON:API relationship shape.
+ * Uses indexed access instead of conditional types to reduce instantiation depth.
+ */
+type InferRelationshipType<T extends RelationshipBuilder> = RelationshipTypeMap<T["type"]>[T["_rel"]];
+/**
+ * Map a relationships schema to the full JSON:API relationships object.
+ */
+type InferRelationships<Schema extends RelationshipsSchema> = {
+    [K in keyof Schema]: InferRelationshipType<Schema[K]>;
+};
+/**
+ * Infer the full JSON:API resource type from a ResourceDefinition.
+ * Uses direct property access instead of conditional + intersection
+ * to reduce type instantiation depth for external consumers.
+ */
+type InferResource<Def extends ResourceDefinition> = {
+    type: Def["resourceType"];
+    id?: string;
+    attributes: InferAttributes<Def["attributes"]>;
+    relationships: InferRelationships<Def["relationships"]>;
+    links?: JsonApiLinks;
+    meta?: JsonApiMeta;
+};
+/**
+ * Extract just the attributes type from a ResourceDefinition.
+ */
+type InferResourceAttributes<Def extends ResourceDefinition> = Def extends ResourceDefinition<string, infer Attrs, RelationshipsSchema> ? InferAttributes<Attrs> : never;
+/**
+ * Extract just the relationships type from a ResourceDefinition.
+ */
+type InferResourceRelationships<Def extends ResourceDefinition> = Def extends ResourceDefinition<string, AttributesSchema, infer Rels> ? InferRelationships<Rels> : never;
+/**
+ * Extract the literal resource type string from a ResourceDefinition.
+ */
+type InferResourceType<Def extends ResourceDefinition> = Def extends ResourceDefinition<infer Type, AttributesSchema, RelationshipsSchema> ? Type : never;
+
+export { type ArrayType, type AttributesSchema, type BooleanType, type DateType, type HasManyRelationship, type HasOneRelationship, type InferAttributes, type InferAttributesSimple, type InferRelationshipType, type InferRelationships, type InferResource, type InferResourceAttributes, type InferResourceRelationships, type InferResourceType, type InferType, type JsonApiCollectionDocument, type JsonApiDocument, type JsonApiDocumentBase, type JsonApiDocumentLinks, type JsonApiEmptyDocument, type JsonApiError, type JsonApiErrorDocument, type JsonApiLinks, type JsonApiMeta, type JsonApiRelationship, type JsonApiRelationships, type JsonApiResource, type JsonApiResourceIdentifier, type JsonApiResponseDocument, type NullableType, type NumberType, type OptionalType, type RelationshipBuilder, type RelationshipsSchema, type ResourceDefinition, type ResourceOptions, type StringType, type TypeBuilder, defineResource, hasMany, hasOne, t };

package/dist/index.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Core JSON:API specification types
+ * @see https://jsonapi.org/format/
+ */
+interface JsonApiResourceIdentifier {
+    type: string;
+    id: string;
+}
+interface JsonApiLinks {
+    self?: string;
+    related?: string;
+    [key: string]: string | undefined;
+}
+type JsonApiMeta = Record<string, unknown>;
+interface JsonApiRelationship {
+    data?: JsonApiResourceIdentifier | JsonApiResourceIdentifier[] | null;
+    links?: JsonApiLinks;
+    meta?: JsonApiMeta;
+}
+interface JsonApiRelationships {
+    [key: string]: JsonApiRelationship;
+}
+interface JsonApiResource<Attr extends Record<string, unknown> = Record<string, unknown>, Rel extends JsonApiRelationships = JsonApiRelationships> {
+    type: string;
+    id?: string;
+    attributes?: Attr;
+    relationships?: Rel;
+    links?: JsonApiLinks;
+    meta?: JsonApiMeta;
+}
+interface JsonApiError {
+    id?: string;
+    status?: string;
+    code?: string;
+    title?: string;
+    detail?: string;
+    source?: {
+        pointer?: string;
+        parameter?: string;
+        header?: string;
+    };
+    meta?: JsonApiMeta;
+}
+interface JsonApiDocumentLinks extends JsonApiLinks {
+    first?: string;
+    last?: string;
+    prev?: string;
+    next?: string;
+}
+interface JsonApiDocumentBase {
+    links?: JsonApiDocumentLinks;
+    meta?: JsonApiMeta;
+    jsonapi?: {
+        version?: string;
+        meta?: JsonApiMeta;
+    };
+}
+
+interface JsonApiDocument<T = JsonApiResource> extends JsonApiDocumentBase {
+    data: T;
+    included?: JsonApiResource[];
+}
+interface JsonApiCollectionDocument<T = JsonApiResource> extends JsonApiDocumentBase {
+    data: T[];
+    included?: JsonApiResource[];
+}
+interface JsonApiErrorDocument extends JsonApiDocumentBase {
+    errors: JsonApiError[];
+}
+interface JsonApiEmptyDocument extends JsonApiDocumentBase {
+    data: null;
+}
+type JsonApiResponseDocument<T = JsonApiResource> = JsonApiDocument<T> | JsonApiCollectionDocument<T> | JsonApiErrorDocument | JsonApiEmptyDocument;
+
+/**
+ * Type builder markers and the `t` namespace
+ *
+ * Each builder is a lightweight runtime object whose TypeScript type
+ * drives compile-time inference via InferType<T>.
+ */
+interface StringType {
+    readonly _type: "string";
+}
+interface NumberType {
+    readonly _type: "number";
+}
+interface BooleanType {
+    readonly _type: "boolean";
+}
+interface DateType {
+    readonly _type: "date";
+}
+interface NullableType<Inner extends TypeBuilder> {
+    readonly _type: "nullable";
+    readonly inner: Inner;
+}
+interface ArrayType<Inner extends TypeBuilder> {
+    readonly _type: "array";
+    readonly inner: Inner;
+}
+interface OptionalType<Inner extends TypeBuilder> {
+    readonly _type: "optional";
+    readonly inner: Inner;
+}
+type TypeBuilder = StringType | NumberType | BooleanType | DateType | NullableType<any> | ArrayType<any> | OptionalType<any>;
+type AttributesSchema = Record<string, TypeBuilder>;
+declare const t: {
+    string: () => StringType;
+    number: () => NumberType;
+    boolean: () => BooleanType;
+    date: () => DateType;
+    nullable: <T extends TypeBuilder>(inner: T) => NullableType<T>;
+    array: <T extends TypeBuilder>(inner: T) => ArrayType<T>;
+    optional: <T extends TypeBuilder>(inner: T) => OptionalType<T>;
+};
+
+/**
+ * Relationship definition helpers
+ */
+interface HasOneRelationship<T extends string = string> {
+    readonly _rel: "one";
+    readonly type: T;
+}
+interface HasManyRelationship<T extends string = string> {
+    readonly _rel: "many";
+    readonly type: T;
+}
+type RelationshipBuilder = HasOneRelationship | HasManyRelationship;
+type RelationshipsSchema = Record<string, RelationshipBuilder>;
+declare const hasOne: <T extends string>(type: T) => HasOneRelationship<T>;
+declare const hasMany: <T extends string>(type: T) => HasManyRelationship<T>;
+
+/**
+ * A resource definition that captures the type-level information
+ * needed for inference.
+ */
+interface ResourceDefinition<Type extends string = string, Attrs extends AttributesSchema = AttributesSchema, Rels extends RelationshipsSchema = RelationshipsSchema> {
+    readonly resourceType: Type;
+    readonly attributes: Attrs;
+    readonly relationships: Rels;
+    readonly createKeys?: readonly string[];
+    readonly updateKeys?: readonly string[];
+}
+/**
+ * Options for per-verb attribute narrowing.
+ * `create` lists which attribute keys are accepted by POST.
+ * `update` lists which attribute keys are accepted by PATCH.
+ */
+interface ResourceOptions<CK extends string = string, UK extends string = string> {
+    readonly create: readonly CK[];
+    readonly update: readonly UK[];
+}
+/** No relationships. */
+declare function defineResource<Type extends string, Attrs extends AttributesSchema>(type: Type, attributes: Attrs): ResourceDefinition<Type, Attrs, Record<string, never>>;
+/** With relationships. */
+declare function defineResource<Type extends string, Attrs extends AttributesSchema, Rels extends RelationshipsSchema>(type: Type, attributes: Attrs, relationships: Rels): ResourceDefinition<Type, Attrs, Rels>;
+/** With relationships + per-verb attribute options. */
+declare function defineResource<Type extends string, Attrs extends AttributesSchema, Rels extends RelationshipsSchema, CK extends keyof Attrs & string, UK extends keyof Attrs & string>(type: Type, attributes: Attrs, relationships: Rels, options: ResourceOptions<CK, UK>): ResourceDefinition<Type, Attrs, Rels> & {
+    readonly createKeys: readonly CK[];
+    readonly updateKeys: readonly UK[];
+};
+
+/**
+ * Leaf type map — resolves primitive builders in a single indexed access
+ * instead of chaining conditional types.
+ */
+interface LeafTypeMap {
+    string: string;
+    number: number;
+    boolean: boolean;
+    date: Date;
+}
+/**
+ * Resolve a leaf TypeBuilder (string/number/boolean/date) to its TS type.
+ */
+type InferLeaf<T extends TypeBuilder> = T extends {
+    readonly _type: infer K extends keyof LeafTypeMap;
+} ? LeafTypeMap[K] : never;
+/**
+ * Resolve one level of wrapper (nullable/array/optional around a leaf).
+ */
+type InferShallow<T extends TypeBuilder> = T extends NullableType<infer I extends TypeBuilder> ? InferLeaf<I> | null : T extends ArrayType<infer I extends TypeBuilder> ? InferLeaf<I>[] : T extends OptionalType<infer I extends TypeBuilder> ? InferLeaf<I> | undefined : InferLeaf<T>;
+/**
+ * Map a TypeBuilder marker to its corresponding TypeScript type.
+ *
+ * Non-recursive: handles up to 2 levels of nesting (e.g. optional(nullable(string))).
+ * This avoids TS2589 when consumed through compiled .d.ts files.
+ */
+type InferType<T extends TypeBuilder> = T extends NullableType<infer I extends TypeBuilder> ? InferShallow<I> | null : T extends ArrayType<infer I extends TypeBuilder> ? InferShallow<I>[] : T extends OptionalType<infer I extends TypeBuilder> ? InferShallow<I> | undefined : InferLeaf<T>;
+type OptionalKeys<Schema extends AttributesSchema> = {
+    [K in keyof Schema]: Schema[K] extends OptionalType<any> ? K : never;
+}[keyof Schema];
+type RequiredKeys<Schema extends AttributesSchema> = Exclude<keyof Schema, OptionalKeys<Schema>>;
+/**
+ * Map an attributes schema to a plain object type.
+ * Keys backed by `t.optional()` become truly optional properties.
+ */
+type InferAttributes<Schema extends AttributesSchema> = {
+    [K in RequiredKeys<Schema>]: InferType<Schema[K]>;
+} & {
+    [K in OptionalKeys<Schema>]?: InferType<Schema[K]>;
+};
+/**
+ * Simplified attribute inference without optional key splitting.
+ * All keys are required. Use this for payload types to reduce instantiation depth.
+ */
+type InferAttributesSimple<Schema extends AttributesSchema> = {
+    [K in keyof Schema]: InferType<Schema[K]>;
+};
+/**
+ * Indexed lookup for relationship shapes — avoids conditional types.
+ */
+interface RelationshipTypeMap<ResourceType extends string> {
+    one: JsonApiRelationship & {
+        data: {
+            type: ResourceType;
+            id: string;
+        } | null;
+    };
+    many: JsonApiRelationship & {
+        data: {
+            type: ResourceType;
+            id: string;
+        }[];
+    };
+}
+/**
+ * Map a single relationship builder to its JSON:API relationship shape.
+ * Uses indexed access instead of conditional types to reduce instantiation depth.
+ */
+type InferRelationshipType<T extends RelationshipBuilder> = RelationshipTypeMap<T["type"]>[T["_rel"]];
+/**
+ * Map a relationships schema to the full JSON:API relationships object.
+ */
+type InferRelationships<Schema extends RelationshipsSchema> = {
+    [K in keyof Schema]: InferRelationshipType<Schema[K]>;
+};
+/**
+ * Infer the full JSON:API resource type from a ResourceDefinition.
+ * Uses direct property access instead of conditional + intersection
+ * to reduce type instantiation depth for external consumers.
+ */
+type InferResource<Def extends ResourceDefinition> = {
+    type: Def["resourceType"];
+    id?: string;
+    attributes: InferAttributes<Def["attributes"]>;
+    relationships: InferRelationships<Def["relationships"]>;
+    links?: JsonApiLinks;
+    meta?: JsonApiMeta;
+};
+/**
+ * Extract just the attributes type from a ResourceDefinition.
+ */
+type InferResourceAttributes<Def extends ResourceDefinition> = Def extends ResourceDefinition<string, infer Attrs, RelationshipsSchema> ? InferAttributes<Attrs> : never;
+/**
+ * Extract just the relationships type from a ResourceDefinition.
+ */
+type InferResourceRelationships<Def extends ResourceDefinition> = Def extends ResourceDefinition<string, AttributesSchema, infer Rels> ? InferRelationships<Rels> : never;
+/**
+ * Extract the literal resource type string from a ResourceDefinition.
+ */
+type InferResourceType<Def extends ResourceDefinition> = Def extends ResourceDefinition<infer Type, AttributesSchema, RelationshipsSchema> ? Type : never;
+
+export { type ArrayType, type AttributesSchema, type BooleanType, type DateType, type HasManyRelationship, type HasOneRelationship, type InferAttributes, type InferAttributesSimple, type InferRelationshipType, type InferRelationships, type InferResource, type InferResourceAttributes, type InferResourceRelationships, type InferResourceType, type InferType, type JsonApiCollectionDocument, type JsonApiDocument, type JsonApiDocumentBase, type JsonApiDocumentLinks, type JsonApiEmptyDocument, type JsonApiError, type JsonApiErrorDocument, type JsonApiLinks, type JsonApiMeta, type JsonApiRelationship, type JsonApiRelationships, type JsonApiResource, type JsonApiResourceIdentifier, type JsonApiResponseDocument, type NullableType, type NumberType, type OptionalType, type RelationshipBuilder, type RelationshipsSchema, type ResourceDefinition, type ResourceOptions, type StringType, type TypeBuilder, defineResource, hasMany, hasOne, t };

package/dist/index.js

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/dsl/types.ts
+var t = {
+  string: () => ({ _type: "string" }),
+  number: () => ({ _type: "number" }),
+  boolean: () => ({ _type: "boolean" }),
+  date: () => ({ _type: "date" }),
+  nullable: (inner) => ({
+    _type: "nullable",
+    inner
+  }),
+  array: (inner) => ({
+    _type: "array",
+    inner
+  }),
+  optional: (inner) => ({
+    _type: "optional",
+    inner
+  })
+};
+
+// src/dsl/relationships.ts
+var hasOne = (type) => ({
+  _rel: "one",
+  type
+});
+var hasMany = (type) => ({
+  _rel: "many",
+  type
+});
+
+// src/dsl/define.ts
+function defineResource(type, attributes, relationships, options) {
+  const def = {
+    resourceType: type,
+    attributes,
+    relationships: relationships ?? {}
+  };
+  if (options) {
+    def.createKeys = options.create;
+    def.updateKeys = options.update;
+  }
+  return def;
+}
+
+exports.defineResource = defineResource;
+exports.hasMany = hasMany;
+exports.hasOne = hasOne;
+exports.t = t;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dsl/types.ts","../src/dsl/relationships.ts","../src/dsl/define.ts"],"names":[],"mappings":";;;AAoDO,IAAM,CAAA,GAAI;AAAA,EACf,MAAA,EAAQ,OAAmB,EAAE,KAAA,EAAO,QAAA,EAAkB,CAAA;AAAA,EACtD,MAAA,EAAQ,OAAmB,EAAE,KAAA,EAAO,QAAA,EAAkB,CAAA;AAAA,EACtD,OAAA,EAAS,OAAoB,EAAE,KAAA,EAAO,SAAA,EAAmB,CAAA;AAAA,EACzD,IAAA,EAAM,OAAiB,EAAE,KAAA,EAAO,MAAA,EAAgB,CAAA;AAAA,EAEhD,QAAA,EAAU,CAAwB,KAAA,MAA+B;AAAA,IAC/D,KAAA,EAAO,UAAA;AAAA,IACP;AAAA,GACF,CAAA;AAAA,EAEA,KAAA,EAAO,CAAwB,KAAA,MAA4B;AAAA,IACzD,KAAA,EAAO,OAAA;AAAA,IACP;AAAA,GACF,CAAA;AAAA,EAEA,QAAA,EAAU,CAAwB,KAAA,MAA+B;AAAA,IAC/D,KAAA,EAAO,UAAA;AAAA,IACP;AAAA,GACF;AACF;;;ACtDO,IAAM,MAAA,GAAS,CAAmB,IAAA,MAAoC;AAAA,EAC3E,IAAA,EAAM,KAAA;AAAA,EACN;AACF,CAAA;AAEO,IAAM,OAAA,GAAU,CAAmB,IAAA,MAAqC;AAAA,EAC7E,IAAA,EAAM,MAAA;AAAA,EACN;AACF,CAAA;;;AC+CO,SAAS,cAAA,CACd,IAAA,EACA,UAAA,EACA,aAAA,EACA,OAAA,EACoB;AACpB,EAAA,MAAM,GAAA,GAA+B;AAAA,IACnC,YAAA,EAAc,IAAA;AAAA,IACd,UAAA;AAAA,IACA,aAAA,EAAe,iBAAiB;AAAC,GACnC;AACA,EAAA,IAAI,OAAA,EAAS;AACX,IAAA,GAAA,CAAI,aAAa,OAAA,CAAQ,MAAA;AACzB,IAAA,GAAA,CAAI,aAAa,OAAA,CAAQ,MAAA;AAAA,EAC3B;AACA,EAAA,OAAO,GAAA;AACT","file":"index.js","sourcesContent":["/**\n * Type builder markers and the `t` namespace\n *\n * Each builder is a lightweight runtime object whose TypeScript type\n * drives compile-time inference via InferType<T>.\n */\n\nexport interface StringType {\n  readonly _type: \"string\";\n}\n\nexport interface NumberType {\n  readonly _type: \"number\";\n}\n\nexport interface BooleanType {\n  readonly _type: \"boolean\";\n}\n\nexport interface DateType {\n  readonly _type: \"date\";\n}\n\nexport interface NullableType<Inner extends TypeBuilder> {\n  readonly _type: \"nullable\";\n  readonly inner: Inner;\n}\n\nexport interface ArrayType<Inner extends TypeBuilder> {\n  readonly _type: \"array\";\n  readonly inner: Inner;\n}\n\nexport interface OptionalType<Inner extends TypeBuilder> {\n  readonly _type: \"optional\";\n  readonly inner: Inner;\n}\n\n// `any` is intentional: NullableType<TypeBuilder> would be circular.\n// The generic parameter on each container type still enforces correctness\n// at the call site (t.nullable(), t.array(), t.optional()).\nexport type TypeBuilder =\n  | StringType\n  | NumberType\n  | BooleanType\n  | DateType\n  | NullableType<any>\n  | ArrayType<any>\n  | OptionalType<any>;\n\nexport type AttributesSchema = Record<string, TypeBuilder>;\n\nexport const t = {\n  string: (): StringType => ({ _type: \"string\" as const }),\n  number: (): NumberType => ({ _type: \"number\" as const }),\n  boolean: (): BooleanType => ({ _type: \"boolean\" as const }),\n  date: (): DateType => ({ _type: \"date\" as const }),\n\n  nullable: <T extends TypeBuilder>(inner: T): NullableType<T> => ({\n    _type: \"nullable\" as const,\n    inner,\n  }),\n\n  array: <T extends TypeBuilder>(inner: T): ArrayType<T> => ({\n    _type: \"array\" as const,\n    inner,\n  }),\n\n  optional: <T extends TypeBuilder>(inner: T): OptionalType<T> => ({\n    _type: \"optional\" as const,\n    inner,\n  }),\n};\n","/**\n * Relationship definition helpers\n */\n\nexport interface HasOneRelationship<T extends string = string> {\n  readonly _rel: \"one\";\n  readonly type: T;\n}\n\nexport interface HasManyRelationship<T extends string = string> {\n  readonly _rel: \"many\";\n  readonly type: T;\n}\n\nexport type RelationshipBuilder = HasOneRelationship | HasManyRelationship;\n\nexport type RelationshipsSchema = Record<string, RelationshipBuilder>;\n\nexport const hasOne = <T extends string>(type: T): HasOneRelationship<T> => ({\n  _rel: \"one\" as const,\n  type,\n});\n\nexport const hasMany = <T extends string>(type: T): HasManyRelationship<T> => ({\n  _rel: \"many\" as const,\n  type,\n});\n","import type { AttributesSchema } from \"./types\";\nimport type { RelationshipsSchema } from \"./relationships\";\n\n/**\n * A resource definition that captures the type-level information\n * needed for inference.\n */\nexport interface ResourceDefinition<\n  Type extends string = string,\n  Attrs extends AttributesSchema = AttributesSchema,\n  Rels extends RelationshipsSchema = RelationshipsSchema,\n> {\n  readonly resourceType: Type;\n  readonly attributes: Attrs;\n  readonly relationships: Rels;\n  readonly createKeys?: readonly string[];\n  readonly updateKeys?: readonly string[];\n}\n\n/**\n * Options for per-verb attribute narrowing.\n * `create` lists which attribute keys are accepted by POST.\n * `update` lists which attribute keys are accepted by PATCH.\n */\nexport interface ResourceOptions<\n  CK extends string = string,\n  UK extends string = string,\n> {\n  readonly create: readonly CK[];\n  readonly update: readonly UK[];\n}\n\n// ── Overloads ────────────────────────────────────────────────────────────\n\n/** No relationships. */\nexport function defineResource<\n  Type extends string,\n  Attrs extends AttributesSchema\n>(\n  type: Type,\n  attributes: Attrs,\n): ResourceDefinition<Type, Attrs, Record<string, never>>;\n\n/** With relationships. */\nexport function defineResource<\n  Type extends string,\n  Attrs extends AttributesSchema,\n  Rels extends RelationshipsSchema\n>(\n  type: Type,\n  attributes: Attrs,\n  relationships: Rels,\n): ResourceDefinition<Type, Attrs, Rels>;\n\n/** With relationships + per-verb attribute options. */\nexport function defineResource<\n  Type extends string,\n  Attrs extends AttributesSchema,\n  Rels extends RelationshipsSchema,\n  CK extends keyof Attrs & string,\n  UK extends keyof Attrs & string,\n>(\n  type: Type,\n  attributes: Attrs,\n  relationships: Rels,\n  options: ResourceOptions<CK, UK>,\n): ResourceDefinition<Type, Attrs, Rels> & {\n  readonly createKeys: readonly CK[];\n  readonly updateKeys: readonly UK[];\n};\n\n// ── Implementation ───────────────────────────────────────────────────────\n\nexport function defineResource(\n  type: string,\n  attributes: AttributesSchema,\n  relationships?: RelationshipsSchema,\n  options?: ResourceOptions,\n): ResourceDefinition {\n  const def: Record<string, unknown> = {\n    resourceType: type,\n    attributes,\n    relationships: relationships ?? {},\n  };\n  if (options) {\n    def.createKeys = options.create;\n    def.updateKeys = options.update;\n  }\n  return def as unknown as ResourceDefinition;\n}\n"]}

package/dist/index.mjs

@@ -0,0 +1,47 @@
+// src/dsl/types.ts
+var t = {
+  string: () => ({ _type: "string" }),
+  number: () => ({ _type: "number" }),
+  boolean: () => ({ _type: "boolean" }),
+  date: () => ({ _type: "date" }),
+  nullable: (inner) => ({
+    _type: "nullable",
+    inner
+  }),
+  array: (inner) => ({
+    _type: "array",
+    inner
+  }),
+  optional: (inner) => ({
+    _type: "optional",
+    inner
+  })
+};
+
+// src/dsl/relationships.ts
+var hasOne = (type) => ({
+  _rel: "one",
+  type
+});
+var hasMany = (type) => ({
+  _rel: "many",
+  type
+});
+
+// src/dsl/define.ts
+function defineResource(type, attributes, relationships, options) {
+  const def = {
+    resourceType: type,
+    attributes,
+    relationships: relationships ?? {}
+  };
+  if (options) {
+    def.createKeys = options.create;
+    def.updateKeys = options.update;
+  }
+  return def;
+}
+
+export { defineResource, hasMany, hasOne, t };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dsl/types.ts","../src/dsl/relationships.ts","../src/dsl/define.ts"],"names":[],"mappings":";AAoDO,IAAM,CAAA,GAAI;AAAA,EACf,MAAA,EAAQ,OAAmB,EAAE,KAAA,EAAO,QAAA,EAAkB,CAAA;AAAA,EACtD,MAAA,EAAQ,OAAmB,EAAE,KAAA,EAAO,QAAA,EAAkB,CAAA;AAAA,EACtD,OAAA,EAAS,OAAoB,EAAE,KAAA,EAAO,SAAA,EAAmB,CAAA;AAAA,EACzD,IAAA,EAAM,OAAiB,EAAE,KAAA,EAAO,MAAA,EAAgB,CAAA;AAAA,EAEhD,QAAA,EAAU,CAAwB,KAAA,MAA+B;AAAA,IAC/D,KAAA,EAAO,UAAA;AAAA,IACP;AAAA,GACF,CAAA;AAAA,EAEA,KAAA,EAAO,CAAwB,KAAA,MAA4B;AAAA,IACzD,KAAA,EAAO,OAAA;AAAA,IACP;AAAA,GACF,CAAA;AAAA,EAEA,QAAA,EAAU,CAAwB,KAAA,MAA+B;AAAA,IAC/D,KAAA,EAAO,UAAA;AAAA,IACP;AAAA,GACF;AACF;;;ACtDO,IAAM,MAAA,GAAS,CAAmB,IAAA,MAAoC;AAAA,EAC3E,IAAA,EAAM,KAAA;AAAA,EACN;AACF,CAAA;AAEO,IAAM,OAAA,GAAU,CAAmB,IAAA,MAAqC;AAAA,EAC7E,IAAA,EAAM,MAAA;AAAA,EACN;AACF,CAAA;;;AC+CO,SAAS,cAAA,CACd,IAAA,EACA,UAAA,EACA,aAAA,EACA,OAAA,EACoB;AACpB,EAAA,MAAM,GAAA,GAA+B;AAAA,IACnC,YAAA,EAAc,IAAA;AAAA,IACd,UAAA;AAAA,IACA,aAAA,EAAe,iBAAiB;AAAC,GACnC;AACA,EAAA,IAAI,OAAA,EAAS;AACX,IAAA,GAAA,CAAI,aAAa,OAAA,CAAQ,MAAA;AACzB,IAAA,GAAA,CAAI,aAAa,OAAA,CAAQ,MAAA;AAAA,EAC3B;AACA,EAAA,OAAO,GAAA;AACT","file":"index.mjs","sourcesContent":["/**\n * Type builder markers and the `t` namespace\n *\n * Each builder is a lightweight runtime object whose TypeScript type\n * drives compile-time inference via InferType<T>.\n */\n\nexport interface StringType {\n  readonly _type: \"string\";\n}\n\nexport interface NumberType {\n  readonly _type: \"number\";\n}\n\nexport interface BooleanType {\n  readonly _type: \"boolean\";\n}\n\nexport interface DateType {\n  readonly _type: \"date\";\n}\n\nexport interface NullableType<Inner extends TypeBuilder> {\n  readonly _type: \"nullable\";\n  readonly inner: Inner;\n}\n\nexport interface ArrayType<Inner extends TypeBuilder> {\n  readonly _type: \"array\";\n  readonly inner: Inner;\n}\n\nexport interface OptionalType<Inner extends TypeBuilder> {\n  readonly _type: \"optional\";\n  readonly inner: Inner;\n}\n\n// `any` is intentional: NullableType<TypeBuilder> would be circular.\n// The generic parameter on each container type still enforces correctness\n// at the call site (t.nullable(), t.array(), t.optional()).\nexport type TypeBuilder =\n  | StringType\n  | NumberType\n  | BooleanType\n  | DateType\n  | NullableType<any>\n  | ArrayType<any>\n  | OptionalType<any>;\n\nexport type AttributesSchema = Record<string, TypeBuilder>;\n\nexport const t = {\n  string: (): StringType => ({ _type: \"string\" as const }),\n  number: (): NumberType => ({ _type: \"number\" as const }),\n  boolean: (): BooleanType => ({ _type: \"boolean\" as const }),\n  date: (): DateType => ({ _type: \"date\" as const }),\n\n  nullable: <T extends TypeBuilder>(inner: T): NullableType<T> => ({\n    _type: \"nullable\" as const,\n    inner,\n  }),\n\n  array: <T extends TypeBuilder>(inner: T): ArrayType<T> => ({\n    _type: \"array\" as const,\n    inner,\n  }),\n\n  optional: <T extends TypeBuilder>(inner: T): OptionalType<T> => ({\n    _type: \"optional\" as const,\n    inner,\n  }),\n};\n","/**\n * Relationship definition helpers\n */\n\nexport interface HasOneRelationship<T extends string = string> {\n  readonly _rel: \"one\";\n  readonly type: T;\n}\n\nexport interface HasManyRelationship<T extends string = string> {\n  readonly _rel: \"many\";\n  readonly type: T;\n}\n\nexport type RelationshipBuilder = HasOneRelationship | HasManyRelationship;\n\nexport type RelationshipsSchema = Record<string, RelationshipBuilder>;\n\nexport const hasOne = <T extends string>(type: T): HasOneRelationship<T> => ({\n  _rel: \"one\" as const,\n  type,\n});\n\nexport const hasMany = <T extends string>(type: T): HasManyRelationship<T> => ({\n  _rel: \"many\" as const,\n  type,\n});\n","import type { AttributesSchema } from \"./types\";\nimport type { RelationshipsSchema } from \"./relationships\";\n\n/**\n * A resource definition that captures the type-level information\n * needed for inference.\n */\nexport interface ResourceDefinition<\n  Type extends string = string,\n  Attrs extends AttributesSchema = AttributesSchema,\n  Rels extends RelationshipsSchema = RelationshipsSchema,\n> {\n  readonly resourceType: Type;\n  readonly attributes: Attrs;\n  readonly relationships: Rels;\n  readonly createKeys?: readonly string[];\n  readonly updateKeys?: readonly string[];\n}\n\n/**\n * Options for per-verb attribute narrowing.\n * `create` lists which attribute keys are accepted by POST.\n * `update` lists which attribute keys are accepted by PATCH.\n */\nexport interface ResourceOptions<\n  CK extends string = string,\n  UK extends string = string,\n> {\n  readonly create: readonly CK[];\n  readonly update: readonly UK[];\n}\n\n// ── Overloads ────────────────────────────────────────────────────────────\n\n/** No relationships. */\nexport function defineResource<\n  Type extends string,\n  Attrs extends AttributesSchema\n>(\n  type: Type,\n  attributes: Attrs,\n): ResourceDefinition<Type, Attrs, Record<string, never>>;\n\n/** With relationships. */\nexport function defineResource<\n  Type extends string,\n  Attrs extends AttributesSchema,\n  Rels extends RelationshipsSchema\n>(\n  type: Type,\n  attributes: Attrs,\n  relationships: Rels,\n): ResourceDefinition<Type, Attrs, Rels>;\n\n/** With relationships + per-verb attribute options. */\nexport function defineResource<\n  Type extends string,\n  Attrs extends AttributesSchema,\n  Rels extends RelationshipsSchema,\n  CK extends keyof Attrs & string,\n  UK extends keyof Attrs & string,\n>(\n  type: Type,\n  attributes: Attrs,\n  relationships: Rels,\n  options: ResourceOptions<CK, UK>,\n): ResourceDefinition<Type, Attrs, Rels> & {\n  readonly createKeys: readonly CK[];\n  readonly updateKeys: readonly UK[];\n};\n\n// ── Implementation ───────────────────────────────────────────────────────\n\nexport function defineResource(\n  type: string,\n  attributes: AttributesSchema,\n  relationships?: RelationshipsSchema,\n  options?: ResourceOptions,\n): ResourceDefinition {\n  const def: Record<string, unknown> = {\n    resourceType: type,\n    attributes,\n    relationships: relationships ?? {},\n  };\n  if (options) {\n    def.createKeys = options.create;\n    def.updateKeys = options.update;\n  }\n  return def as unknown as ResourceDefinition;\n}\n"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@leodamours/jsonapi-dsl",
+  "version": "1.0.0",
+  "description": "A TypeScript-first DSL for JSON:API — typed resource definitions, relationships, and inference",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "jsonapi",
+    "json:api",
+    "typescript",
+    "types",
+    "type-safe",
+    "type-inference",
+    "schema",
+    "dsl"
+  ],
+  "author": "Leo Damours",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LeoDamours/json-api-client.git",
+    "directory": "packages/dsl"
+  },
+  "homepage": "https://github.com/LeoDamours/json-api-client/tree/main/packages/dsl",
+  "bugs": "https://github.com/LeoDamours/json-api-client/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "tsup": "^8.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "LICENSE"
+  ]
+}