@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.3

package/dist/esm/authorization/roles/resources.js

@@ -0,0 +1,48 @@
+import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { addPaginationToURL, parseEgressSchema, } from '../../common/resources/utils.js';
+import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
+import { InsertRolePayloadSchema, RoleSchema, UpdateRolePayloadSchema, } from './schema.js';
+const PATH = '/v1/authorization/roles';
+export class RoleResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(id) {
+        if (id?.startsWith(PATH)) {
+            return id;
+        }
+        return [PATH, id].filter(Boolean).join('/');
+    }
+    listItems(pagination) {
+        return listRoles(this.instance, pagination);
+    }
+    getItem(id) {
+        return getRole(this.instance, id);
+    }
+    insertItem(item) {
+        return insertRole(this.instance, item);
+    }
+    updateItem(id, item) {
+        return updateRole(this.instance, id, item);
+    }
+    deleteItem(id) {
+        return deleteRole(this.instance, id);
+    }
+}
+export async function listRoles(instance, pagination) {
+    const url = addPaginationToURL(new URL(RoleResources.buildPath(), instance.config.host), pagination);
+    return parseEgressSchema(PaginationCollectionSchema(RoleSchema)(await getItemWithAuthorization(url, instance.authorizer)));
+}
+export async function getRole(instance, id) {
+    return parseEgressSchema(RoleSchema(await getItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer)));
+}
+export async function insertRole(instance, item) {
+    return parseEgressSchema(RoleSchema(await insertItemWithAuthorization(new URL(RoleResources.buildPath(), instance.config.host), instance.authorizer, parseEgressSchema(InsertRolePayloadSchema.onUndeclaredKey('delete')(item)))));
+}
+export async function updateRole(instance, id, item) {
+    return parseEgressSchema(RoleSchema(await updateItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer, parseEgressSchema(UpdateRolePayloadSchema.onUndeclaredKey('delete')(item)))));
+}
+export async function deleteRole(instance, id) {
+    await deleteItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer);
+}

package/dist/esm/authorization/roles/schema.d.ts

@@ -0,0 +1,113 @@
+export declare const RoleStatus: {
+    readonly ENABLED: "enabled";
+    readonly DISABLED: "disabled";
+};
+export type AnyRoleStatus = (typeof RoleStatus)[keyof typeof RoleStatus];
+export declare const RoleIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type RoleIdProperty = typeof RoleIdPropertySchema.inferOut;
+export declare const RoleAssociationsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    apps?: string[] | undefined;
+    permissions?: string[] | undefined;
+    users?: string[] | undefined;
+}, {}>;
+export type RoleAssociations = typeof RoleAssociationsSchema.inferOut;
+export declare const RoleSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    description?: string | undefined;
+    apps?: {
+        ids?: string[] | undefined;
+        count?: number | undefined;
+    } | undefined;
+    users?: {
+        ids?: string[] | undefined;
+        count?: number | undefined;
+    } | undefined;
+    permissions?: {
+        ids?: string[] | undefined;
+        count?: number | undefined;
+    } | undefined;
+    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype/internal/attributes.ts").Out<Map<string, string | number | boolean> | Map<string, any>>;
+}, {}>;
+export type RoleProperties = typeof RoleSchema.inferIn;
+export type Role = typeof RoleSchema.inferOut;
+export declare const RolePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    description?: string | undefined;
+    apps?: {
+        ids?: string[] | undefined;
+        count?: number | undefined;
+    } | undefined;
+    users?: {
+        ids?: string[] | undefined;
+        count?: number | undefined;
+    } | undefined;
+    permissions?: {
+        ids?: string[] | undefined;
+        count?: number | undefined;
+    } | undefined;
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type RolePayload = typeof RolePayloadSchema.inferOut;
+/**
+ * Insert
+ */
+export declare const InsertRolePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").Default<string, string>;
+    name: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    description?: string | undefined;
+    apps?: string[] | undefined;
+    permissions?: string[] | undefined;
+    users?: string[] | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type InsertRoleInput = typeof InsertRolePayloadSchema.inferIn;
+export type InsertRolePayload = typeof InsertRolePayloadSchema.inferOut;
+/**
+ * Update
+ */
+export declare const UpdateRolePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    name?: string | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    description?: string | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type UpdateRoleInput = typeof UpdateRolePayloadSchema.inferIn;
+export type UpdateRolePayload = typeof UpdateRolePayloadSchema.inferOut;
+/**
+ * Association
+ */
+export declare const RoleAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    model: "Role";
+}, {}>;
+export type RoleAssociationReference = typeof RoleAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/authorization/roles/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authorization/roles/schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAIzE,eAAO,MAAM,oBAAoB;;MAE/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAMlE,eAAO,MAAM,sBAAsB;;;;MAIjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAWtE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;MAOU,CAAC;AAClC,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC,OAAO,CAAC;AACvD,MAAM,MAAM,IAAI,GAAG,OAAO,UAAU,CAAC,QAAQ,CAAC;AAE9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;MAOO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;MAOC,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;MAIC,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;MAMzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

package/dist/esm/authorization/roles/schema.js

@@ -0,0 +1,69 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/index.js';
+import { AggregateSchema } from '../../common/schema/aggregate.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { generateRoleId } from '../utils.js';
+export const RoleStatus = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+const RoleIdSchema = type.string;
+export const RoleIdPropertySchema = type({
+    id: RoleIdSchema,
+});
+const StatusSchema = type.enumerated(RoleStatus.ENABLED, RoleStatus.DISABLED);
+const AssociationSchema = type('string[] | undefined');
+export const RoleAssociationsSchema = type({
+    apps: AssociationSchema.optional(),
+    permissions: AssociationSchema.optional(),
+    users: AssociationSchema.optional(),
+});
+const BaseSchema = RoleIdPropertySchema.and({
+    name: type('string'),
+    status: StatusSchema,
+    description: type('string').optional(),
+    apps: AggregateSchema.optional(),
+    users: AggregateSchema.optional(),
+    permissions: AggregateSchema.optional(),
+});
+export const RoleSchema = BaseSchema.and({
+    createdAt: RequiredDateSchema,
+    updatedAt: RequiredDateSchema,
+    'deletedAt?': OptionalDateSchema,
+    'deactivatedAt?': OptionalDateSchema,
+})
+    .and(RoleIdPropertySchema)
+    .and(MetadataMapPropertySchema);
+export const RolePayloadSchema = BaseSchema.and({
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+})
+    .and(RoleIdPropertySchema)
+    .and(MetadataPayloadPropertySchema);
+/**
+ * Insert
+ */
+export const InsertRolePayloadSchema = type({
+    id: RoleIdSchema.default(() => generateRoleId()),
+    name: type('string'),
+    status: StatusSchema.default(RoleStatus.ENABLED),
+    description: type('string').optional(),
+})
+    .and(RoleAssociationsSchema)
+    .and(MetadataPayloadPropertySchema);
+/**
+ * Update
+ */
+export const UpdateRolePayloadSchema = type({
+    name: type('string').optional(),
+    status: StatusSchema.optional(),
+    description: type('string').optional(),
+}).and(MetadataPayloadPropertySchema);
+/**
+ * Association
+ */
+export const RoleAssociationReferenceSchema = RolePayloadSchema.pick('id', 'name', 'status').and({
+    model: "'Role'",
+});

package/dist/esm/authorization/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const Model: {
+    readonly Permission: {
+        readonly UIDPrefix: "per";
+    };
+    readonly Role: {
+        readonly UIDPrefix: "rol";
+    };
+};
+export declare function generatePermissionId(): string;
+export declare function generateRoleId(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/authorization/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/authorization/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX,wBAAgB,oBAAoB,WAEnC;AAED,wBAAgB,cAAc,WAE7B"}

package/dist/esm/authorization/utils.js

@@ -0,0 +1,15 @@
+import KSUID from 'ksuid';
+export const Model = {
+    Permission: {
+        UIDPrefix: 'per',
+    },
+    Role: {
+        UIDPrefix: 'rol',
+    },
+};
+export function generatePermissionId() {
+    return `${Model.Permission.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export function generateRoleId() {
+    return `${Model.Role.UIDPrefix}_${KSUID.randomSync().string}`;
+}

package/dist/esm/common/errors/http.d.ts

@@ -0,0 +1,17 @@
+export type HttpErrorOptions = {
+    statusCode?: number;
+    type?: string;
+    trace?: string;
+    body?: {
+        [key: string]: string;
+    };
+};
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly type: string;
+    readonly trace?: HttpErrorOptions['trace'];
+    readonly body?: HttpErrorOptions['body'];
+    constructor(message?: string, options?: HttpErrorOptions);
+    get isAuthorizationError(): boolean;
+}
+//# sourceMappingURL=http.d.ts.map

package/dist/esm/common/errors/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/http.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE;QACL,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;KACvB,CAAC;CACH,CAAC;AAEF,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;gBAGvC,OAAO,SAA+D,EACtE,OAAO,CAAC,EAAE,gBAAgB;IAQ5B,IAAI,oBAAoB,IAAI,OAAO,CAElC;CACF"}

package/dist/esm/common/errors/http.js

@@ -0,0 +1,14 @@
+export class HttpError extends Error {
+    statusCode;
+    type;
+    trace;
+    body;
+    constructor(message = 'An unknown error occurred. Please try the operation again.', options) {
+        super(message);
+        this.statusCode = options?.statusCode || 500;
+        this.type = options?.type || 'Unknown';
+    }
+    get isAuthorizationError() {
+        return [401, 403].includes(this.statusCode);
+    }
+}

package/dist/esm/common/errors/validation.d.ts

@@ -0,0 +1,11 @@
+import { HttpError, type HttpErrorOptions } from './http.js';
+export type ValidationErrorOptions = HttpErrorOptions & {
+    fields: {
+        [key: string]: string;
+    };
+};
+export declare class ValidationError extends HttpError {
+    readonly fields: ValidationErrorOptions['fields'];
+    constructor(message: string, options: ValidationErrorOptions);
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/esm/common/errors/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG;IACtD,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,CAAC;gBAE/B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;CAIpE"}

package/dist/esm/common/errors/validation.js

@@ -0,0 +1,8 @@
+import { HttpError } from './http.js';
+export class ValidationError extends HttpError {
+    fields;
+    constructor(message, options) {
+        super(message, options);
+        this.fields = options?.fields;
+    }
+}

package/dist/esm/common/index.d.ts

@@ -0,0 +1,6 @@
+import { MondoIdentity } from './resources/init.js';
+export * from './errors/http.js';
+export * from './errors/validation.js';
+export * from './schema/schema.js';
+export default MondoIdentity;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,oBAAoB,CAAC;AAEnC,eAAe,aAAa,CAAC"}

package/dist/esm/common/index.js

@@ -0,0 +1,5 @@
+import { MondoIdentity } from './resources/init.js';
+export * from './errors/http.js';
+export * from './errors/validation.js';
+export * from './schema/schema.js';
+export default MondoIdentity;

package/dist/esm/common/resources/authorization.d.ts

@@ -0,0 +1,2 @@
+export type Authorization = (request: RequestInit) => RequestInit;
+//# sourceMappingURL=authorization.d.ts.map

package/dist/esm/common/resources/authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/authorization.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,WAAW,KAAK,WAAW,CAAC"}

package/dist/esm/common/resources/authorization.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/common/resources/init.d.ts

@@ -0,0 +1,16 @@
+declare const ConfigSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    host: (In: import("arktype/internal/attributes.ts").Default<string, "https://manage-api.mondoidentity.com">) => import("arktype/internal/attributes.ts").To<URL>;
+    accessToken: string;
+}, {}>;
+type ConfigProps = typeof ConfigSchema.inferIn;
+type Config = typeof ConfigSchema.inferOut;
+export declare class MondoIdentity {
+    readonly config: Config;
+    constructor(config: ConfigProps);
+    /**
+     * Builds an authorizer function based on the type of access token
+     */
+    get authorizer(): (request: RequestInit) => RequestInit;
+}
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/esm/common/resources/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/init.ts"],"names":[],"mappings":"AAYA,QAAA,MAAM,YAAY;;;MAA0B,CAAC;AAE7C,KAAK,WAAW,GAAG,OAAO,YAAY,CAAC,OAAO,CAAC;AAC/C,KAAK,MAAM,GAAG,OAAO,YAAY,CAAC,QAAQ,CAAC;AAE3C,qBAAa,aAAa;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEL,MAAM,EAAE,WAAW;IAItC;;OAEG;IACH,IAAW,UAAU,IAAI,CAAC,OAAO,EAAE,WAAW,KAAK,WAAW,CAU7D;CAuBF"}

package/dist/esm/common/resources/init.js

@@ -0,0 +1,34 @@
+import { type } from 'arktype';
+const BaseConfigSchema = type({
+    host: type('string.url.parse').default('https://manage-api.mondoidentity.com'),
+});
+const AccessTokenConfigSchema = BaseConfigSchema.and({
+    accessToken: type('string'),
+});
+const ConfigSchema = AccessTokenConfigSchema;
+export class MondoIdentity {
+    config;
+    constructor(config) {
+        this.config = initConfig(config);
+    }
+    /**
+     * Builds an authorizer function based on the type of access token
+     */
+    get authorizer() {
+        if (this.config.accessToken) {
+            return (request) => {
+                request.headers = new Headers(request.headers);
+                request.headers.append('authorization', this.config.accessToken);
+                return request;
+            };
+        }
+        return (request) => request;
+    }
+}
+function initConfig(config) {
+    const out = ConfigSchema(config);
+    if (out instanceof type.errors) {
+        throw new Error(`Invalid configuration: ${out.summary}`);
+    }
+    return out;
+}

package/dist/esm/common/resources/operations.d.ts

@@ -0,0 +1,7 @@
+import type { Authorization } from './authorization.js';
+export declare function listItemsWithAuthorization<Result>(url: URL, authorization: Authorization): Promise<Result>;
+export declare function getItemWithAuthorization<Result>(url: URL, authorization: Authorization): Promise<Result>;
+export declare function updateItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item: Mutation): Promise<Result>;
+export declare function insertItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item?: Mutation): Promise<Result>;
+export declare function deleteItemWithAuthorization<Result>(url: URL, authorization: Authorization): Promise<Result>;
+//# sourceMappingURL=operations.d.ts.map

package/dist/esm/common/resources/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASxD,wBAAsB,0BAA0B,CAAC,MAAM,EACrD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,wBAAwB,CAAC,MAAM,EACnD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,QAAQ,EAChE,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,QAAQ,EAChE,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,CAAC,EAAE,QAAQ,GACd,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EACtD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB"}

package/dist/esm/common/resources/operations.js

@@ -0,0 +1,83 @@
+import { defaultMutationRequestHeaders, defaultRequestHeaders, jsonBody, responseToHttpError, toHttpError, } from './utils.js';
+export async function listItemsWithAuthorization(url, authorization) {
+    try {
+        console.debug('List items', { url });
+        const response = await fetch(url, authorization({
+            method: 'GET',
+            headers: defaultRequestHeaders(),
+        }));
+        if (response.ok) {
+            return await response.json();
+        }
+        throw await responseToHttpError(response);
+    }
+    catch (error) {
+        throw toHttpError(error);
+    }
+}
+export async function getItemWithAuthorization(url, authorization) {
+    try {
+        console.debug('Get item', { url });
+        const response = await fetch(url, authorization({
+            method: 'GET',
+            headers: defaultRequestHeaders(),
+        }));
+        if (response.ok) {
+            return await response.json();
+        }
+        throw await responseToHttpError(response);
+    }
+    catch (error) {
+        throw toHttpError(error);
+    }
+}
+export async function updateItemWithAuthorization(url, authorization, item) {
+    try {
+        console.debug('Update item', { url, item });
+        const response = await fetch(url, authorization({
+            method: 'PUT',
+            headers: defaultMutationRequestHeaders(),
+            body: JSON.stringify(item),
+        }));
+        if (response.ok) {
+            return await response.json();
+        }
+        throw await responseToHttpError(response);
+    }
+    catch (error) {
+        throw toHttpError(error);
+    }
+}
+export async function insertItemWithAuthorization(url, authorization, item) {
+    try {
+        console.debug('Insert item', { url, item });
+        const response = await fetch(url, authorization({
+            method: 'POST',
+            headers: defaultMutationRequestHeaders(),
+            body: item ? JSON.stringify(item) : undefined,
+        }));
+        if (response.ok) {
+            return await response.json();
+        }
+        throw await responseToHttpError(response);
+    }
+    catch (error) {
+        throw toHttpError(error);
+    }
+}
+export async function deleteItemWithAuthorization(url, authorization) {
+    try {
+        console.debug('Delete item', { url });
+        const response = await fetch(url, authorization({
+            method: 'DELETE',
+            headers: defaultRequestHeaders(),
+        }));
+        if (response.ok) {
+            return (await jsonBody(response));
+        }
+        throw await responseToHttpError(response);
+    }
+    catch (error) {
+        throw toHttpError(error);
+    }
+}

package/dist/esm/common/resources/utils.d.ts

@@ -0,0 +1,18 @@
+import { type } from 'arktype';
+import { HttpError } from '../errors/http.js';
+import type { Pagination } from '../schema/pagination.js';
+/**
+ * Parse schema data that is calling the API
+ */
+export declare function parseEgressSchema<S>(output: S | type.errors): S;
+/**
+ * Parse schema data that is returning from the API
+ */
+export declare function parseIngressSchema<S>(output: S | type.errors): S;
+export declare function defaultRequestHeaders(): Headers;
+export declare function defaultMutationRequestHeaders(): Headers;
+export declare function jsonBody<R>(message: Request | Response): Promise<R | undefined>;
+export declare function addPaginationToURL(url: URL, pagination?: Pagination): URL;
+export declare function responseToHttpError(response: Response): Promise<HttpError>;
+export declare function toHttpError(error: unknown): HttpError;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/common/resources/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAU/D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAQhE;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED,wBAAgB,6BAA6B,IAAI,OAAO,CAMvD;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,OAAO,EAAE,OAAO,GAAG,QAAQ,GAC1B,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAMxB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,CAUzE;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,SAAS,CAAC,CAmCpB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAUrD"}

package/dist/esm/common/resources/utils.js

@@ -0,0 +1,86 @@
+import { type } from 'arktype';
+import { HttpError } from '../errors/http.js';
+import { ValidationError } from '../errors/validation.js';
+/**
+ * Parse schema data that is calling the API
+ */
+export function parseEgressSchema(output) {
+    if (output instanceof type.errors) {
+        console.warn(`Failed to parse egress payload: ${output.summary}`, {
+            error: output,
+        });
+        throw output;
+    }
+    return output;
+}
+/**
+ * Parse schema data that is returning from the API
+ */
+export function parseIngressSchema(output) {
+    if (output instanceof type.errors) {
+        console.warn(`Failed to parse ingress payload: ${output.summary}`, {
+            error: output,
+        });
+    }
+    return output;
+}
+export function defaultRequestHeaders() {
+    return new Headers([['accept', 'application/json']]);
+}
+export function defaultMutationRequestHeaders() {
+    const headers = defaultRequestHeaders();
+    headers.append('Content-Type', 'application/json');
+    return headers;
+}
+export async function jsonBody(message) {
+    try {
+        return await message.json();
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+export function addPaginationToURL(url, pagination) {
+    if (pagination?.nextToken != null) {
+        url.searchParams.set('pagination[nextToken]', pagination.nextToken);
+    }
+    if (pagination?.pageSize != null) {
+        url.searchParams.set('pagination[pageSize]', String(pagination.pageSize));
+    }
+    return url;
+}
+export async function responseToHttpError(response) {
+    const body = await response.json();
+    // Authorization errors
+    if ([401, 403].includes(response.status)) {
+        return new HttpError(body?.error_description || 'Unauthorized', {
+            statusCode: response.status,
+            type: body?.error || 'authorization',
+        });
+    }
+    const { error: type, error_description: message, trace, fields, ...data } = body;
+    if (fields) {
+        return new ValidationError(message, {
+            statusCode: response.status,
+            type,
+            trace,
+            body: data,
+            fields,
+        });
+    }
+    return new HttpError(message, {
+        statusCode: response.status,
+        type,
+        trace,
+        body: data,
+    });
+}
+export function toHttpError(error) {
+    if (error instanceof HttpError) {
+        return error;
+    }
+    if (error && typeof error === 'object' && 'message' in error) {
+        return new HttpError(String(error.message));
+    }
+    return new HttpError();
+}

package/dist/esm/common/schema/aggregate.d.ts

@@ -0,0 +1,6 @@
+export declare const AggregateSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    ids?: string[] | undefined;
+    count?: number | undefined;
+}, {}>;
+export type Aggregate = typeof AggregateSchema.inferOut;
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/esm/common/schema/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/aggregate.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;MAG1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,QAAQ,CAAC"}

package/dist/esm/common/schema/aggregate.js

@@ -0,0 +1,5 @@
+import { type } from 'arktype';
+export const AggregateSchema = type({
+    ids: type('string[]').optional(),
+    count: type('number').optional(),
+});