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

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEgressSchema = parseEgressSchema;
+exports.parseIngressSchema = parseIngressSchema;
+exports.defaultRequestHeaders = defaultRequestHeaders;
+exports.defaultMutationRequestHeaders = defaultMutationRequestHeaders;
+exports.jsonBody = jsonBody;
+exports.addPaginationToURL = addPaginationToURL;
+exports.responseToHttpError = responseToHttpError;
+exports.toHttpError = toHttpError;
+const arktype_1 = require("arktype");
+const http_js_1 = require("../errors/http.js");
+const validation_js_1 = require("../errors/validation.js");
+/**
+ * Parse schema data that is calling the API
+ */
+function parseEgressSchema(output) {
+    if (output instanceof arktype_1.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
+ */
+function parseIngressSchema(output) {
+    if (output instanceof arktype_1.type.errors) {
+        console.warn(`Failed to parse ingress payload: ${output.summary}`, {
+            error: output,
+        });
+    }
+    return output;
+}
+function defaultRequestHeaders() {
+    return new Headers([['accept', 'application/json']]);
+}
+function defaultMutationRequestHeaders() {
+    const headers = defaultRequestHeaders();
+    headers.append('Content-Type', 'application/json');
+    return headers;
+}
+async function jsonBody(message) {
+    try {
+        return await message.json();
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+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;
+}
+async function responseToHttpError(response) {
+    const body = await response.json();
+    // Authorization errors
+    if ([401, 403].includes(response.status)) {
+        return new http_js_1.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 validation_js_1.ValidationError(message, {
+            statusCode: response.status,
+            type,
+            trace,
+            body: data,
+            fields,
+        });
+    }
+    return new http_js_1.HttpError(message, {
+        statusCode: response.status,
+        type,
+        trace,
+        body: data,
+    });
+}
+function toHttpError(error) {
+    if (error instanceof http_js_1.HttpError) {
+        return error;
+    }
+    if (error && typeof error === 'object' && 'message' in error) {
+        return new http_js_1.HttpError(String(error.message));
+    }
+    return new http_js_1.HttpError();
+}

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

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

package/dist/cjs/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/cjs/common/schema/aggregate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateSchema = void 0;
+const arktype_1 = require("arktype");
+exports.AggregateSchema = (0, arktype_1.type)({
+    ids: (0, arktype_1.type)('string[]').optional(),
+    count: (0, arktype_1.type)('number').optional(),
+});

package/dist/cjs/common/schema/collection.d.ts

@@ -0,0 +1,18 @@
+import { type Pagination } from './pagination.js';
+export declare const CollectionSchema: import("arktype").Generic<[["t", unknown]], {
+    readonly items: "t[]";
+}, {}, {}>;
+export type Collection<I> = {
+    items: I[];
+};
+export declare const PaginationCollectionSchema: import("arktype").Generic<[["t", unknown]], {
+    readonly items: "t[]";
+    readonly pagination: [import("arktype/out/methods/object.js").ObjectType<{
+        pageSize?: string | number | undefined;
+        nextToken?: string | undefined;
+    }, {}>, "?"];
+}, {}, {}>;
+export type PaginationCollection<I> = Collection<I> & {
+    pagination?: Pagination;
+};
+//# sourceMappingURL=collection.d.ts.map

package/dist/cjs/common/schema/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/collection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,iBAAiB,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;UAAgC,CAAC;AAC9D,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;UAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACpD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC"}

package/dist/cjs/common/schema/collection.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationCollectionSchema = exports.CollectionSchema = void 0;
+const arktype_1 = require("arktype");
+const pagination_js_1 = require("./pagination.js");
+exports.CollectionSchema = (0, arktype_1.type)('<t>', { items: 't[]' });
+exports.PaginationCollectionSchema = (0, arktype_1.type)('<t>', {
+    items: 't[]',
+    pagination: pagination_js_1.PaginationSchema.optional(),
+});

package/dist/cjs/common/schema/dates.d.ts

@@ -0,0 +1,39 @@
+export declare const RequiredDateSchema: import("arktype/out/methods/object").ObjectType<Date | ((In: string) => import("arktype/out/attributes").To<Date>), {}>;
+export declare const OptionalDateSchema: import("arktype/out/methods/base").BaseType<Date | ((In: string) => import("arktype/out/attributes").To<Date>) | undefined, {}>;
+export type AnyRequiredDateType = typeof RequiredDateSchema.inferIn;
+export type RequiredDate = typeof RequiredDateSchema.inferOut;
+export type AnyOptionalDate = typeof OptionalDateSchema.inferIn;
+export type OptionalDate = typeof OptionalDateSchema.inferOut;
+export declare const RequiredDatePayloadSchema: import("arktype/out/methods/object").ObjectType<(In: string | Date) => import("arktype/out/attributes").Out<string>, {}>;
+export declare const OptionalDatePayloadSchema: import("arktype/out/methods/object").ObjectType<(In: string | Date | undefined) => import("arktype/out/attributes").Out<string | undefined>, {}>;
+export type RequiredDatePayload = typeof RequiredDatePayloadSchema.inferOut;
+export type OptionalDatePayload = typeof OptionalDatePayloadSchema.inferOut;
+/**
+ * Created At
+ */
+export declare const CreatedAtPropertyPayloadSchema: import("arktype/out/methods/object").ObjectType<{
+    createdAt: (In: string | Date) => import("arktype/out/attributes").Out<string>;
+}, {}>;
+export type CreatedAtPropertyPayload = typeof CreatedAtPropertyPayloadSchema.inferOut;
+/**
+ * Updated At
+ */
+export declare const UpdatedAtPropertyPayloadSchema: import("arktype/out/methods/object").ObjectType<{
+    updatedAt: (In: string | Date) => import("arktype/out/attributes").Out<string>;
+}, {}>;
+export type UpdatedAtPropertyPayload = typeof UpdatedAtPropertyPayloadSchema.inferOut;
+/**
+ * Deleted At
+ */
+export declare const DeletedAtPropertyPayloadSchema: import("arktype/out/methods/object").ObjectType<{
+    deletedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes").Out<string | undefined>) | undefined;
+}, {}>;
+export type DeletedAtPropertyPayload = typeof DeletedAtPropertyPayloadSchema.inferOut;
+/**
+ * Deactivated At
+ */
+export declare const DeactivatedAtPropertyPayloadSchema: import("arktype/out/methods/object").ObjectType<{
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes").Out<string | undefined>) | undefined;
+}, {}>;
+export type DeactivatedAtPropertyPayload = typeof DeactivatedAtPropertyPayloadSchema.inferOut;
+//# sourceMappingURL=dates.d.ts.map

package/dist/cjs/common/schema/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,yHAA2C,CAAC;AAC3E,eAAO,MAAM,kBAAkB,iIAAqC,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAG9D,eAAO,MAAM,yBAAyB,0HAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,kJAErC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,kCAAkC;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC"}

package/dist/cjs/common/schema/dates.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeactivatedAtPropertyPayloadSchema = exports.DeletedAtPropertyPayloadSchema = exports.UpdatedAtPropertyPayloadSchema = exports.CreatedAtPropertyPayloadSchema = exports.OptionalDatePayloadSchema = exports.RequiredDatePayloadSchema = exports.OptionalDateSchema = exports.RequiredDateSchema = void 0;
+const arktype_1 = require("arktype");
+// Normalizing to a Date object
+exports.RequiredDateSchema = (0, arktype_1.type)('Date').or('string.date.iso.parse');
+exports.OptionalDateSchema = exports.RequiredDateSchema.or('undefined');
+// What the class property is serialized to
+exports.RequiredDatePayloadSchema = exports.RequiredDateSchema.pipe.try((d) => d.toISOString());
+exports.OptionalDatePayloadSchema = exports.OptionalDateSchema.pipe.try((d) => d?.toISOString());
+/**
+ * Created At
+ */
+exports.CreatedAtPropertyPayloadSchema = (0, arktype_1.type)({
+    createdAt: exports.RequiredDatePayloadSchema,
+});
+/**
+ * Updated At
+ */
+exports.UpdatedAtPropertyPayloadSchema = (0, arktype_1.type)({
+    updatedAt: exports.RequiredDatePayloadSchema,
+});
+/**
+ * Deleted At
+ */
+exports.DeletedAtPropertyPayloadSchema = (0, arktype_1.type)({
+    'deletedAt?': exports.OptionalDatePayloadSchema,
+});
+/**
+ * Deactivated At
+ */
+exports.DeactivatedAtPropertyPayloadSchema = (0, arktype_1.type)({
+    'deactivatedAt?': exports.OptionalDatePayloadSchema,
+});

package/dist/cjs/common/schema/dates.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dates.test.d.ts.map

package/dist/cjs/common/schema/dates.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.test.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.test.ts"],"names":[],"mappings":""}

package/dist/cjs/common/schema/dates.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const arktype_1 = require("arktype");
+const vitest_1 = require("vitest");
+const dates_js_1 = require("./dates.js");
+(0, vitest_1.describe)('Common - Dates', () => {
+    (0, vitest_1.describe)('Date Schema', () => {
+        (0, vitest_1.test)('should accept an iso string', async () => {
+            const result = (0, dates_js_1.RequiredDateSchema)(new Date().toISOString());
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toBeInstanceOf(Date);
+        });
+        (0, vitest_1.test)('should accept a Date object', async () => {
+            const result = (0, dates_js_1.RequiredDateSchema)(new Date());
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toBeInstanceOf(Date);
+        });
+    });
+    (0, vitest_1.describe)('Payload Schema', () => {
+        (0, vitest_1.test)('should parse a Date to an ISO string', async () => {
+            const iso = new Date().toISOString();
+            const result = (0, dates_js_1.RequiredDatePayloadSchema)(new Date(iso));
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).to.equal(iso);
+        });
+        (0, vitest_1.test)('should parse an ISO to an ISO string', async () => {
+            const iso = new Date().toISOString();
+            const result = (0, dates_js_1.RequiredDatePayloadSchema)(iso);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).to.equal(iso);
+        });
+    });
+});

package/dist/cjs/common/schema/jwt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
+ */
+export declare const Algorithm: {
+    DEFAULT: string;
+    HS256: string;
+    HS384: string;
+    HS512: string;
+    RS256: string;
+    RS384: string;
+    RS512: string;
+    ES256: string;
+    ES384: string;
+    ES512: string;
+    PS256: string;
+    PS384: string;
+    PS512: string;
+};
+export type AnyAlgorithm = (typeof Algorithm)[keyof typeof Algorithm];
+export declare const AlgorithmSchema: import("arktype/out/methods/string").StringType<string, {}>;
+//# sourceMappingURL=jwt.d.ts.map

package/dist/cjs/common/schema/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/jwt.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;CAerB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe,6DAY3B,CAAC"}

package/dist/cjs/common/schema/jwt.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlgorithmSchema = exports.Algorithm = void 0;
+const arktype_1 = require("arktype");
+/**
+ * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
+ */
+exports.Algorithm = {
+    // DEFAULT: 'ES256',
+    DEFAULT: 'RS256',
+    HS256: 'HS256',
+    HS384: 'HS384',
+    HS512: 'HS512',
+    RS256: 'RS256',
+    RS384: 'RS384',
+    RS512: 'RS512',
+    ES256: 'ES256',
+    ES384: 'ES384',
+    ES512: 'ES512',
+    PS256: 'PS256',
+    PS384: 'PS384',
+    PS512: 'PS512',
+};
+exports.AlgorithmSchema = arktype_1.type.enumerated(exports.Algorithm.HS256, exports.Algorithm.HS384, exports.Algorithm.HS512, exports.Algorithm.RS256, exports.Algorithm.RS384, exports.Algorithm.RS512, exports.Algorithm.ES256, exports.Algorithm.ES384, exports.Algorithm.PS256, exports.Algorithm.PS384, exports.Algorithm.PS512);

package/dist/cjs/common/schema/metadata.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Record
+ */
+declare const MetadataRecordSchema: import("arktype/out/methods/object").ObjectType<{
+    [x: string]: string | number | boolean;
+}, {}>;
+type MetadataRecord = typeof MetadataRecordSchema.inferOut;
+/**
+ * Map
+ */
+declare const MetadataMapSchema: import("arktype/out/methods/object").ObjectType<Map<string, string | number | boolean>, {}>;
+export type MetadataMap = typeof MetadataMapSchema.inferOut;
+export declare const MetadataPayloadSchema: import("arktype/out/methods/object").ObjectType<(In: {
+    [x: string]: string | number | boolean;
+} | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes").Out<{
+    [x: string]: string | number | boolean;
+} | undefined>, {}>;
+export type MetadataPayload = typeof MetadataPayloadSchema.inferOut;
+export declare const MetadataPayloadPropertySchema: import("arktype/out/methods/object").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type MetadataPayloadProperty = typeof MetadataPayloadPropertySchema.inferOut;
+export declare const UpsertMetadataPayloadSchema: import("arktype/out/methods/object").ObjectType<(In: {
+    [x: string]: string | number | boolean;
+} | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes").Out<{
+    [x: string]: string | number | boolean;
+} | null>, {}>;
+export declare const UpsertMetadataPayloadPropertySchema: import("arktype/out/methods/object").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export type UpsertMetadataPayloadProperty = typeof UpsertMetadataPayloadPropertySchema.inferOut;
+export declare function buildMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | undefined;
+export declare function buildUpsertMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | null;
+export declare const MetadataMapPropertySchema: import("arktype/out/methods/object").ObjectType<{
+    metadata: (In: import("arktype/out/attributes").Default<unknown, Map<string, string | number | boolean>>) => import("arktype/out/attributes").Out<Map<string, string | number | boolean> | Map<string, any>>;
+}, {}>;
+export type MetadataMapProperty = typeof MetadataMapPropertySchema.inferOut;
+export {};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/cjs/common/schema/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,QAAA,MAAM,oBAAoB;;MAA4C,CAAC;AACvE,KAAK,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAE3D;;GAEG;AACH,QAAA,MAAM,iBAAiB,6FAEtB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAoB5D,eAAO,MAAM,qBAAqB;;;;mBAG6B,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,6BAA6B;;;;;;MAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,2BAA2B;;;;cAGgC,CAAC;AAEzE,eAAO,MAAM,mCAAmC;;;;;;MAE9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,SAAS,CAgB5B;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,IAAI,CAgBvB;AAQD,eAAO,MAAM,yBAAyB;;MAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC"}

package/dist/cjs/common/schema/metadata.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataMapPropertySchema = exports.UpsertMetadataPayloadPropertySchema = exports.UpsertMetadataPayloadSchema = exports.MetadataPayloadPropertySchema = exports.MetadataPayloadSchema = void 0;
+exports.buildMetadataPayload = buildMetadataPayload;
+exports.buildUpsertMetadataPayload = buildUpsertMetadataPayload;
+const arktype_1 = require("arktype");
+/**
+ * Value
+ */
+const MetadataValueSchema = (0, arktype_1.type)('string | number | boolean');
+/**
+ * Record
+ */
+const MetadataRecordSchema = (0, arktype_1.type)({ '[string]': MetadataValueSchema });
+/**
+ * Map
+ */
+const MetadataMapSchema = arktype_1.type.instanceOf((Map));
+/**
+ * Record To Map
+ */
+const MetadataMapMatch = (0, arktype_1.match)({
+    undefined: () => new Map(),
+})
+    .case(MetadataMapSchema, (s) => new Map(s))
+    .case(MetadataMapSchema, (s) => new Map(Object.entries(s || {}).map(([key, value]) => [key, value])))
+    .default(() => new Map());
+exports.MetadataPayloadSchema = (0, arktype_1.type)('undefined | null')
+    .or(MetadataMapSchema)
+    .or(MetadataRecordSchema)
+    .pipe((map) => (map ? buildMetadataPayload(map) : undefined));
+exports.MetadataPayloadPropertySchema = (0, arktype_1.type)({
+    'metadata?': exports.MetadataPayloadSchema,
+});
+exports.UpsertMetadataPayloadSchema = (0, arktype_1.type)('undefined | null')
+    .or(MetadataMapSchema)
+    .or(MetadataRecordSchema)
+    .pipe((map) => (map ? buildUpsertMetadataPayload(map) || null : null));
+exports.UpsertMetadataPayloadPropertySchema = (0, arktype_1.type)({
+    'metadata?': exports.UpsertMetadataPayloadSchema,
+});
+function buildMetadataPayload(map) {
+    if (!(map instanceof Map)) {
+        return map;
+    }
+    const result = Array.from(map.entries()).reduce((result, [key, value]) => {
+        if (value == null || value === '') {
+            return result;
+        }
+        Object.assign(result, { [key]: value });
+        return result;
+    }, {});
+    return Object.keys(result).length ? result : undefined;
+}
+function buildUpsertMetadataPayload(map) {
+    if (!(map instanceof Map)) {
+        return map;
+    }
+    const result = Array.from(map.entries()).reduce((result, [key, value]) => {
+        if (value == null || value === '') {
+            return result;
+        }
+        Object.assign(result, { [key]: value });
+        return result;
+    }, {});
+    return Object.keys(result).length ? result : null;
+}
+/**
+ * Map
+ */
+const ToMetadataMapSchema = MetadataMapMatch.default(() => new Map());
+exports.MetadataMapPropertySchema = (0, arktype_1.type)({
+    metadata: ToMetadataMapSchema,
+});
+// export const metadataAttributeScope = scope({
+//   metadata: MetadataAttributeMatch.default(
+//     () => new Map<string, typeof MetadataAttributeValueSchema.inferOut>(),
+//   ),
+// });
+// export const metadataPropertyScope = scope({
+//   'metadata?': MetadataPropertyItemSchema,
+// });
+// export const serializedMetadataScope = scope({
+//   metadata: SerializedMetadataSchema,
+// });
+// export const storageMetadataScope = scope({
+//   metadata: StorageMetadataSchema,
+// });

package/dist/cjs/common/schema/metadata.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metadata.test.d.ts.map

package/dist/cjs/common/schema/metadata.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.test.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.test.ts"],"names":[],"mappings":""}

package/dist/cjs/common/schema/metadata.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const arktype_1 = require("arktype");
+const vitest_1 = require("vitest");
+const metadata_js_1 = require("./metadata.js");
+(0, vitest_1.describe)('Common - Metadata', () => {
+    (0, vitest_1.describe)('Map Property Schema', () => {
+        (0, vitest_1.test)('should parse a record to a map', async () => {
+            const result = (0, metadata_js_1.MetadataMapPropertySchema)({
+                metadata: { foo: 'bar' },
+            });
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata).toBeInstanceOf(Map);
+        });
+        (0, vitest_1.test)('should parse undefined property to a map', async () => {
+            const result = (0, metadata_js_1.MetadataMapPropertySchema)({
+                metadata: undefined,
+            });
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata).toBeInstanceOf(Map);
+        });
+        (0, vitest_1.test)('should parse undefined to a map', async () => {
+            const result = (0, metadata_js_1.MetadataMapPropertySchema)({});
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata).toBeInstanceOf(Map);
+        });
+        (0, vitest_1.test)('should parse map to a map', async () => {
+            const result = (0, metadata_js_1.MetadataMapPropertySchema)({
+                metadata: new Map([['foo', 'bar']]),
+            });
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata).toBeInstanceOf(Map);
+        });
+        (0, vitest_1.test)('should parse null to a map', async () => {
+            const result = (0, metadata_js_1.MetadataMapPropertySchema)({
+                metadata: null,
+            });
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata).toBeInstanceOf(Map);
+        });
+    });
+    (0, vitest_1.describe)('Payload', () => {
+        (0, vitest_1.test)('should parse map to record', async () => {
+            const result = (0, metadata_js_1.MetadataPayloadPropertySchema)({
+                metadata: new Map([
+                    ['foo', 'bar'],
+                    ['baz', 0],
+                ]),
+            });
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata?.foo).to.equal('bar');
+            (0, vitest_1.expect)(result?.metadata?.baz).to.equal(0);
+        });
+        (0, vitest_1.test)('should return undefined if map is empty', async () => {
+            const result = (0, metadata_js_1.MetadataPayloadPropertySchema)({
+                metadata: new Map(),
+            });
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result?.metadata).is.undefined;
+        });
+    });
+});

package/dist/cjs/common/schema/pagination.d.ts

@@ -0,0 +1,6 @@
+export declare const PaginationSchema: import("arktype/out/methods/object").ObjectType<{
+    pageSize?: string | number | undefined;
+    nextToken?: string | undefined;
+}, {}>;
+export type Pagination = typeof PaginationSchema.inferOut;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/cjs/common/schema/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/pagination.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;MAG3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC"}

package/dist/cjs/common/schema/pagination.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationSchema = void 0;
+const arktype_1 = require("arktype");
+exports.PaginationSchema = (0, arktype_1.type)({
+    pageSize: (0, arktype_1.type)('string | number').optional(),
+    nextToken: (0, arktype_1.type)('string').optional(),
+});

package/dist/cjs/common/schema/schema.d.ts

@@ -0,0 +1,8 @@
+export * from './aggregate.js';
+export * from './collection.js';
+export * from './dates.js';
+export * from './jwt.js';
+export * from './metadata.js';
+export * from './pagination.js';
+export * from './sets.js';
+//# sourceMappingURL=schema.d.ts.map

package/dist/cjs/common/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/schema.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/dist/cjs/common/schema/schema.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aggregate.js"), exports);
+__exportStar(require("./collection.js"), exports);
+__exportStar(require("./dates.js"), exports);
+__exportStar(require("./jwt.js"), exports);
+__exportStar(require("./metadata.js"), exports);
+__exportStar(require("./pagination.js"), exports);
+__exportStar(require("./sets.js"), exports);

package/dist/cjs/common/schema/sets.d.ts

@@ -0,0 +1,3 @@
+export declare const UniqueStringSetPayloadSchema: import("arktype/out/methods/object").ObjectType<Set<string> | ((In: string[]) => import("arktype/out/attributes").Out<Set<string>>), {}>;
+export declare const UniqueStringSetPayload: import("arktype/out/methods/object").ObjectType<(In: Set<string> | string[]) => import("arktype/out/attributes").Out<string[]>, {}>;
+//# sourceMappingURL=sets.d.ts.map

package/dist/cjs/common/schema/sets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/sets.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,4BAA4B,0IAAiC,CAAC;AAC3E,eAAO,MAAM,sBAAsB,qIAElC,CAAC"}

package/dist/cjs/common/schema/sets.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueStringSetPayload = exports.UniqueStringSetPayloadSchema = void 0;
+const arktype_1 = require("arktype");
+const StringArraySchema = (0, arktype_1.type)('string[]');
+const StringArrayToSet = StringArraySchema.pipe((s) => new Set(s));
+const StringSet = arktype_1.type.instanceOf((Set));
+exports.UniqueStringSetPayloadSchema = StringSet.or(StringArrayToSet);
+exports.UniqueStringSetPayload = exports.UniqueStringSetPayloadSchema.pipe((s) => Array.from(s.values()));

package/dist/cjs/customer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './schema/schema.js';
+export * from './users/resources.js';
+export * from './users/schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/customer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/customer/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AAEnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC"}