@go-mondo/identity-sdk 0.0.1-beta.2

package/lib/esm/authorization/schema/permission.d.ts

@@ -0,0 +1,69 @@
+export declare const PermissionStatus: {
+    readonly ENABLED: "enabled";
+    readonly DISABLED: "disabled";
+};
+export type AnyPermissionStatus = (typeof PermissionStatus)[keyof typeof PermissionStatus];
+export declare const PermissionIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type PermissionIdProperty = typeof PermissionIdPropertySchema.inferOut;
+export declare const PermissionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    description?: string | undefined;
+    apps?: {
+        ids?: string[] | undefined;
+        count?: number[] | undefined;
+    } | undefined;
+    roles?: {
+        ids?: string[] | undefined;
+        count?: number[] | undefined;
+    } | undefined;
+    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 PermissionPayload = typeof PermissionPayloadSchema.inferOut;
+export declare const InsertPermissionPayloadSchema: 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;
+    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 InsertPermissionPayload = typeof InsertPermissionPayloadSchema.inferOut;
+export declare const UpdatePermissionPayloadSchema: 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 UpdatePermissionPayload = typeof UpdatePermissionPayloadSchema.inferOut;
+export declare const PermissionAssociationsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    apps?: string[] | undefined;
+    roles?: string[] | undefined;
+}, {}>;
+export type PermissionAssociations = typeof PermissionAssociationsSchema.inferOut;
+export declare const PermissionAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    model: "Permission";
+}, {}>;
+export type PermissionAssociationReference = typeof PermissionAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=permission.d.ts.map

package/lib/esm/authorization/schema/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../../../src/authorization/schema/permission.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAI3D,eAAO,MAAM,0BAA0B;;MAErC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAO9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;MAYC,CAAC;AACtC,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,6BAA6B;;;;;;;;;;MAKL,CAAC;AACtC,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,6BAA6B;;;;;;;;;MAIL,CAAC;AACtC,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAIhD,eAAO,MAAM,4BAA4B;;;MAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC;AAE/C,eAAO,MAAM,oCAAoC;;;;;MAG7C,CAAC;AACL,MAAM,MAAM,8BAA8B,GACxC,OAAO,oCAAoC,CAAC,QAAQ,CAAC"}

package/lib/esm/authorization/schema/permission.js

@@ -0,0 +1,47 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
+import { AggregateSchema } from '../../common/schema/aggregate.js';
+import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import { generatePermissionId } from './utils.js';
+export const PermissionStatus = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+const PermissionIdSchema = type.string;
+export const PermissionIdPropertySchema = type({
+    id: PermissionIdSchema,
+});
+const StatusSchema = type.enumerated(PermissionStatus.ENABLED, PermissionStatus.DISABLED);
+export const PermissionPayloadSchema = PermissionIdPropertySchema.and({
+    name: type('string'),
+    status: StatusSchema,
+    description: type('string').optional(),
+    apps: AggregateSchema.optional(),
+    roles: AggregateSchema.optional(),
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+})
+    .and(PermissionIdPropertySchema)
+    .and(MetadataPayloadPropertySchema);
+export const InsertPermissionPayloadSchema = type({
+    id: PermissionIdSchema.default(() => generatePermissionId()),
+    name: type('string'),
+    status: StatusSchema.default(PermissionStatus.ENABLED),
+    description: type('string').optional(),
+}).and(MetadataPayloadPropertySchema);
+export const UpdatePermissionPayloadSchema = type({
+    name: type('string').optional(),
+    status: StatusSchema.optional(),
+    description: type('string').optional(),
+}).and(MetadataPayloadPropertySchema);
+const AssociationSchema = type('string[] | undefined');
+export const PermissionAssociationsSchema = type({
+    '+': 'delete',
+    apps: AssociationSchema.optional(),
+    roles: AssociationSchema.optional(),
+});
+export const PermissionAssociationReferenceSchema = PermissionPayloadSchema.pick('id', 'name', 'status').and({
+    model: "'Permission'",
+});

package/lib/esm/authorization/schema/role.d.ts

@@ -0,0 +1,74 @@
+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 RolePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    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;
+    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;
+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;
+    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 InsertRolePayload = typeof InsertRolePayloadSchema.inferOut;
+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 UpdateRolePayload = typeof UpdateRolePayloadSchema.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 RoleAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    status: "enabled" | "disabled";
+    model: "Role";
+}, {}>;
+export type RoleAssociationReference = typeof RoleAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=role.d.ts.map

package/lib/esm/authorization/schema/role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","sourceRoot":"","sources":["../../../../src/authorization/schema/role.ts"],"names":[],"mappings":"AASA,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;AAIlE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;MAaO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D,eAAO,MAAM,uBAAuB;;;;;;;;;;MAKC,CAAC;AACtC,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;;;;MAIC,CAAC;AACtC,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAIxE,eAAO,MAAM,sBAAsB;;;;MAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,8BAA8B;;;;;MAMzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

package/lib/esm/authorization/schema/role.js

@@ -0,0 +1,49 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
+import { AggregateSchema } from '../../common/schema/aggregate.js';
+import { 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);
+export const RolePayloadSchema = RoleIdPropertySchema.and({
+    name: type('string'),
+    status: StatusSchema,
+    description: type('string').optional(),
+    apps: AggregateSchema.optional(),
+    users: AggregateSchema.optional(),
+    permissions: AggregateSchema.optional(),
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+})
+    .and(RoleIdPropertySchema)
+    .and(MetadataPayloadPropertySchema);
+export const InsertRolePayloadSchema = type({
+    id: RoleIdSchema.default(() => generateRoleId()),
+    name: type('string'),
+    status: StatusSchema.default(RoleStatus.ENABLED),
+    description: type('string').optional(),
+}).and(MetadataPayloadPropertySchema);
+export const UpdateRolePayloadSchema = type({
+    name: type('string').optional(),
+    status: StatusSchema.optional(),
+    description: type('string').optional(),
+}).and(MetadataPayloadPropertySchema);
+const AssociationSchema = type('string[] | undefined');
+export const RoleAssociationsSchema = type({
+    '+': 'delete',
+    apps: AssociationSchema.optional(),
+    permissions: AssociationSchema.optional(),
+    users: AssociationSchema.optional(),
+});
+export const RoleAssociationReferenceSchema = RolePayloadSchema.pick('id', 'name', 'status').and({
+    model: "'Role'",
+});

package/lib/esm/authorization/schema/schema.d.ts

@@ -0,0 +1,4 @@
+export * from './permission.js';
+export * from './role.js';
+export * from './utils.js';
+//# sourceMappingURL=schema.d.ts.map

package/lib/esm/authorization/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authorization/schema/schema.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAE1B,cAAc,YAAY,CAAC"}

package/lib/esm/authorization/schema/schema.js

@@ -0,0 +1,3 @@
+export * from './permission.js';
+export * from './role.js';
+export * from './utils.js';

package/lib/esm/authorization/schema/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/lib/esm/authorization/schema/utils.d.ts.map

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

package/lib/esm/authorization/schema/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/lib/esm/common/index.d.ts

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

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

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

package/lib/esm/common/index.js

@@ -0,0 +1 @@
+export * from './schema/schema.js';

package/lib/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/lib/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/lib/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(),
+});

package/lib/esm/common/schema/dates.d.ts

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

package/lib/esm/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,yIAA2C,CAAC;AAC3E,eAAO,MAAM,kBAAkB,iJAAqC,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,0IAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,kKAErC,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/lib/esm/common/schema/dates.js

@@ -0,0 +1,31 @@
+import { type } from 'arktype';
+// Normalizing to a Date object
+export const RequiredDateSchema = type('Date').or('string.date.iso.parse');
+export const OptionalDateSchema = RequiredDateSchema.or('undefined');
+// What the class property is serialized to
+export const RequiredDatePayloadSchema = RequiredDateSchema.pipe.try((d) => d.toISOString());
+export const OptionalDatePayloadSchema = OptionalDateSchema.pipe.try((d) => d?.toISOString());
+/**
+ * Created At
+ */
+export const CreatedAtPropertyPayloadSchema = type({
+    createdAt: RequiredDatePayloadSchema,
+});
+/**
+ * Updated At
+ */
+export const UpdatedAtPropertyPayloadSchema = type({
+    updatedAt: RequiredDatePayloadSchema,
+});
+/**
+ * Deleted At
+ */
+export const DeletedAtPropertyPayloadSchema = type({
+    'deletedAt?': OptionalDatePayloadSchema,
+});
+/**
+ * Deactivated At
+ */
+export const DeactivatedAtPropertyPayloadSchema = type({
+    'deactivatedAt?': OptionalDatePayloadSchema,
+});

package/lib/esm/common/schema/dates.test.d.ts

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

package/lib/esm/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/lib/esm/common/schema/dates.test.js

@@ -0,0 +1,31 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { RequiredDatePayloadSchema, RequiredDateSchema } from './dates.js';
+describe('Common - Dates', () => {
+    describe('Date Schema', () => {
+        test('should accept an iso string', async () => {
+            const result = RequiredDateSchema(new Date().toISOString());
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Date);
+        });
+        test('should accept a Date object', async () => {
+            const result = RequiredDateSchema(new Date());
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Date);
+        });
+    });
+    describe('Payload Schema', () => {
+        test('should parse a Date to an ISO string', async () => {
+            const iso = new Date().toISOString();
+            const result = RequiredDatePayloadSchema(new Date(iso));
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).to.equal(iso);
+        });
+        test('should parse an ISO to an ISO string', async () => {
+            const iso = new Date().toISOString();
+            const result = RequiredDatePayloadSchema(iso);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).to.equal(iso);
+        });
+    });
+});

package/lib/esm/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/internal/methods/string.ts").StringType<string, {}>;
+//# sourceMappingURL=jwt.d.ts.map

package/lib/esm/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,qEAY3B,CAAC"}

package/lib/esm/common/schema/jwt.js

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+/**
+ * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
+ */
+export const 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',
+};
+export const AlgorithmSchema = type.enumerated(Algorithm.HS256, Algorithm.HS384, Algorithm.HS512, Algorithm.RS256, Algorithm.RS384, Algorithm.RS512, Algorithm.ES256, Algorithm.ES384, Algorithm.PS256, Algorithm.PS384, Algorithm.PS512);

package/lib/esm/common/schema/metadata.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Record
+ */
+declare const MetadataRecordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    [x: string]: string | number | boolean;
+}, {}>;
+type MetadataRecord = typeof MetadataRecordSchema.inferOut;
+/**
+ * Map
+ */
+declare const MetadataMapSchema: import("arktype/internal/methods/object.ts").ObjectType<Map<string, string | number | boolean>, {}>;
+export type MetadataMap = typeof MetadataMapSchema.inferOut;
+export declare const MetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(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>, {}>;
+export type MetadataPayload = typeof MetadataPayloadSchema.inferOut;
+export declare const MetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    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 MetadataPayloadProperty = typeof MetadataPayloadPropertySchema.inferOut;
+export declare const UpsertMetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    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;
+    } | 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/internal/methods/object.ts").ObjectType<{
+    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 MetadataMapProperty = typeof MetadataMapPropertySchema.inferOut;
+export {};
+//# sourceMappingURL=metadata.d.ts.map

package/lib/esm/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,qGAEtB,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;AAOhD,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/lib/esm/common/schema/metadata.js

@@ -0,0 +1,83 @@
+import { match, type } from 'arktype';
+/**
+ * Value
+ */
+const MetadataValueSchema = type('string | number | boolean');
+/**
+ * Record
+ */
+const MetadataRecordSchema = type({ '[string]': MetadataValueSchema });
+/**
+ * Map
+ */
+const MetadataMapSchema = type.instanceOf((Map));
+/**
+ * Record To Map
+ */
+const MetadataMapMatch = 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());
+export const MetadataPayloadSchema = type('undefined | null')
+    .or(MetadataMapSchema)
+    .or(MetadataRecordSchema)
+    .pipe((map) => (map ? buildMetadataPayload(map) : undefined));
+export const MetadataPayloadPropertySchema = type({
+    'metadata?': MetadataPayloadSchema,
+});
+const UpsertMetadataPayloadSchema = type('undefined | null')
+    .or(MetadataMapSchema)
+    .or(MetadataRecordSchema)
+    .pipe((map) => (map ? buildUpsertMetadataPayload(map) || null : null));
+export const UpsertMetadataPayloadPropertySchema = type({
+    'metadata?': UpsertMetadataPayloadSchema,
+});
+export 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;
+}
+export 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());
+export const MetadataMapPropertySchema = 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/lib/esm/common/schema/metadata.test.d.ts

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

package/lib/esm/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":""}