@aventara/client 0.1.0-pilot.4 → 1.0.0-rc.1

package/dist/emit/json-shape.emitter.js

@@ -0,0 +1,88 @@
+const SCALAR_TYPES = {
+    string: "string",
+    number: "number",
+    integer: "number",
+    boolean: "boolean",
+    null: "null",
+};
+const plain = (text) => ({ text, union: false });
+function unionOf(members) {
+    return members.length === 1
+        ? members[0]
+        : { text: members.map((member) => member.text).join(" | "), union: true };
+}
+function operand(type) {
+    return type.union ? `(${type.text})` : type.text;
+}
+function emitted(schema) {
+    if (Object.hasOwn(schema, "const")) {
+        return plain(JSON.stringify(schema.const));
+    }
+    if (Array.isArray(schema.enum)) {
+        return unionOf(schema.enum.map((value) => plain(JSON.stringify(value))));
+    }
+    for (const keyword of ["anyOf", "oneOf"]) {
+        const options = schema[keyword];
+        if (Array.isArray(options)) {
+            return unionOf(options.map((option) => emitted(option)));
+        }
+    }
+    const type = schema.type;
+    if (typeof type === "string" && Object.hasOwn(SCALAR_TYPES, type)) {
+        return plain(SCALAR_TYPES[type]);
+    }
+    if (type === "array") {
+        if (Array.isArray(schema.prefixItems)) {
+            return plain(`[${schema.prefixItems.map((item) => emitted(item).text).join(", ")}]`);
+        }
+        return plain(`${operand(emitted(schema.items))}[]`);
+    }
+    if (type === "object") {
+        const properties = schema.properties;
+        if (properties === undefined) {
+            return plain(`{ [key: string]: ${emitted(schema.additionalProperties).text} }`);
+        }
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        const members = Object.keys(properties).map((key) => {
+            const member = emitted(properties[key]).text;
+            return required.has(key)
+                ? `${JSON.stringify(key)}: ${member}`
+                : `${JSON.stringify(key)}?: ${member} | undefined`;
+        });
+        return plain(members.length === 0 ? "{}" : `{ ${members.join("; ")} }`);
+    }
+    throw new Error(`a Json Shape schema outside the accepted forms reached the emitter: ${JSON.stringify(schema)}`);
+}
+export function jsonSchemaType(schema) {
+    return emitted(schema).text;
+}
+export function shapedContractType(contract) {
+    const order = (keys) => [...keys].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+    const resources = order(Object.keys(contract.resources)).flatMap((resourceName) => {
+        const fields = contract.resources[resourceName]?.fields ?? {};
+        const shaped = order(Object.keys(fields)).flatMap((fieldName) => {
+            const field = fields[fieldName];
+            return field?.kind === "scalar" && field.json !== undefined
+                ? [
+                    `\t\t\t\treadonly ${JSON.stringify(fieldName)}: { readonly json: JsonFieldType<${jsonSchemaType(field.json)}> };\n`,
+                ]
+                : [];
+        });
+        return shaped.length === 0
+            ? []
+            : [
+                `\t\treadonly ${JSON.stringify(resourceName)}: {\n` +
+                    "\t\t\treadonly fields: {\n" +
+                    shaped.join("") +
+                    "\t\t\t};\n" +
+                    "\t\t};\n",
+            ];
+    });
+    return resources.length === 0
+        ? undefined
+        : "ClientContractShape & {\n" +
+            "\treadonly resources: {\n" +
+            resources.join("") +
+            "\t};\n" +
+            "}";
+}

package/dist/emit/name.deriver.d.ts

@@ -1,11 +1,11 @@
-import { type ClientContract, type OperationFamily } from "@aventara/core";
+import type { AvContractClient, AvOperationFamily } from "@aventara/core";
 /**
  * Name derivation and the rename ladder for the emitted tree.
  */
 export declare const RESERVED_EMITTED_NAMES: readonly string[];
 export interface ResourceNamedType {
     readonly suffix: string;
-    readonly family: OperationFamily;
+    readonly family: AvOperationFamily;
     readonly variant: string;
     /** The argument it names; absent for `X`, the default record. */
     readonly argument?: "where" | "orderBy" | "data" | "select" | "include";
@@ -43,12 +43,12 @@ export declare function isIdentifierName(text: string): boolean;
  * The emitted names of a Contract's enums and Resources, renamed where a name
  * cannot be declared as-is.
  *
- * @throws GeneratedNameError naming every name no rung of its ladder can repair.
+ * @throws AvGeneratedNameError naming every name no rung of its ladder can repair.
  */
-export declare function deriveEmittedNames(contract: Pick<ClientContract, "enums" | "resources">): EmittedNames;
+export declare function deriveEmittedNames(contract: Pick<AvContractClient, "enums" | "resources">): EmittedNames;
 /** The refusal that stops generation over names no rename can repair. */
-export declare class GeneratedNameError extends Error {
-    readonly name = "GeneratedNameError";
+export declare class AvGeneratedNameError extends Error {
+    readonly name = "AvGeneratedNameError";
     constructor(problems: readonly string[]);
 }
 export declare function ownPropertyKey(value: string): string;

package/dist/emit/name.deriver.js

@@ -1,22 +1,22 @@
-import { isOperationVariantAvailable, } from "@aventara/core";
+import { isOperationVariantAvailable } from "@aventara/core/internal";
 import { FRAMEWORK_ERROR_CLASS_NAMES } from "./runtime.emitter.js";
 export const RESERVED_EMITTED_NAMES = [
     ...new Set([
         "AvClient",
         "AvClientOptions",
-        "CallOptions",
-        "Cause",
-        "Decimal",
-        "Fetch",
-        "FrameworkError",
-        "NotFoundError",
-        "Operation",
-        "OperationCode",
+        "AvCallOptions",
+        "AvCause",
+        "AvDecimal",
+        "AvFetch",
+        "AvError",
+        "AvNotFoundError",
+        "AvOperation",
+        "AvOperationCode",
         "ResourceArgument",
         "ResourceRecord",
-        "TransportError",
-        "ValidationCode",
-        "ValidationIssue",
+        "AvTransportError",
+        "AvValidationCode",
+        "AvValidationIssue",
         "avClient",
         ...FRAMEWORK_ERROR_CLASS_NAMES,
     ]),
@@ -214,7 +214,7 @@ export function deriveEmittedNames(contract) {
     const enums = enumNames.map((name) => resolve("enum", name));
     const properties = resourceProperties(resourceNames, warnings, refusals);
     if (refusals.length > 0) {
-        throw new GeneratedNameError(byName(refusals));
+        throw new AvGeneratedNameError(byName(refusals));
     }
     return { enums, resources, properties, warnings: byName(warnings) };
 }
@@ -262,8 +262,8 @@ function byName(lines) {
 function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-export class GeneratedNameError extends Error {
-    name = "GeneratedNameError";
+export class AvGeneratedNameError extends Error {
+    name = "AvGeneratedNameError";
     constructor(problems) {
         super(`the ClientContract's names cannot all be emitted: ${problems.join("; ")}. ` +
             `Rename ${problems.length === 1 ? "it" : "them"} on the server, then generate again.`);

package/dist/emit/named-type.emitter.d.ts

@@ -1,5 +1,5 @@
-import type { ClientContract } from "@aventara/core";
+import type { AvContractClient } from "@aventara/core";
 import type { EmittedModule } from "./emitted-tree.interface.js";
 import { type ClientModuleStyle } from "./module-style.interface.js";
 import { type EmittedNames } from "./name.deriver.js";
-export declare function emitNamedTypesModule(contract: ClientContract, names: EmittedNames, style: ClientModuleStyle): EmittedModule;
+export declare function emitNamedTypesModule(contract: AvContractClient, names: EmittedNames, style: ClientModuleStyle): EmittedModule;

package/dist/emit/runtime.emitter.d.ts

@@ -1,9 +1,9 @@
-import { type ClientContract } from "@aventara/core";
+import type { AvContractClient } from "@aventara/core";
 import type { ClientEntrypoint } from "../config/client-config.interface.js";
 import type { EmittedModule } from "./emitted-tree.interface.js";
 import { type ClientModuleStyle } from "./module-style.interface.js";
 export declare function emitDecimalModule(): EmittedModule;
-export declare function emitMetadataModule(protocol: ClientContract["protocol"], entrypoint: ClientEntrypoint): EmittedModule;
+export declare function emitMetadataModule(protocol: AvContractClient["protocol"], entrypoint: ClientEntrypoint): EmittedModule;
 export declare const FRAMEWORK_ERROR_CLASS_NAMES: readonly string[];
 export declare function errorsModuleExports(): readonly string[];
 export declare function emitErrorsModule(): EmittedModule;