@go-mondo/identity-sdk 0.0.2-beta.39 → 0.0.2-beta.40

package/dist/esm/app/registration/resources.js

@@ -1,4 +1,4 @@
-import { getItemWithAuthorization, insertItemWithAuthorization, } from '../../common/resources/operations.js';
+import { getItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { PATH } from '../resources.js';
 import { RegistrationSchema, UpsertRegistrationPayloadSchema, } from './schema.js';
 const RESOURCE = 'registration';
@@ -24,5 +24,5 @@ export async function getRegistration(instance, id) {
     return RegistrationSchema.parse(await getItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer));
 }
 export async function upsertRegistration(instance, id, item) {
-    return RegistrationSchema.parse(await insertItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer, UpsertRegistrationPayloadSchema.parse(item)));
+    return RegistrationSchema.parse(await postItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer, UpsertRegistrationPayloadSchema.parse(item)));
 }

package/dist/esm/app/resources.js

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, patchItemWithAuthorization, postItemWithAuthorization, } from '../common/resources/operations.js';
 import { addPaginationToURL } from '../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../common/schema/collection.js';
 import { AppSchema, InsertAppPayloadSchema, UpdateAppPayloadSchema, } from './schema.js';
@@ -38,10 +38,10 @@ export async function getApp(instance, id) {
     return AppSchema.parse(await getItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer));
 }
 export async function insertApp(instance, item) {
-    return AppSchema.parse(await insertItemWithAuthorization(new URL(AppResources.buildPath(), instance.config.host), instance.authorizer, InsertAppPayloadSchema.parse));
+    return AppSchema.parse(await postItemWithAuthorization(new URL(AppResources.buildPath(), instance.config.host), instance.authorizer, InsertAppPayloadSchema.parse));
 }
 export async function updateApp(instance, id, item) {
-    return AppSchema.parse(await updateItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer, UpdateAppPayloadSchema.parse(item)));
+    return AppSchema.parse(await patchItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer, UpdateAppPayloadSchema.parse(item)));
 }
 export async function deleteApp(instance, id) {
     return AppSchema.parse(await deleteItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer));

package/dist/esm/app/saml/resources.js

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, patchItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { PATH } from '../resources.js';
 import { InsertSAMLPayloadSchema, SAMLSchema, UpdateSAMLPayloadSchema, } from './schema.js';
 const RESOURCE = 'saml';
@@ -30,10 +30,10 @@ export async function getSAML(instance, appId) {
     return SAMLSchema.parse(await getItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer));
 }
 export async function insertSAML(instance, appId, item) {
-    return SAMLSchema.parse(await insertItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer, item ? InsertSAMLPayloadSchema.parse(item) : undefined));
+    return SAMLSchema.parse(await postItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer, item ? InsertSAMLPayloadSchema.parse(item) : undefined));
 }
 export async function updateSAML(instance, appId, item) {
-    return SAMLSchema.parse(await updateItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer, UpdateSAMLPayloadSchema.parse(item)));
+    return SAMLSchema.parse(await patchItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer, UpdateSAMLPayloadSchema.parse(item)));
 }
 export async function deleteSAML(instance, appId) {
     return SAMLSchema.parse(await deleteItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer));

package/dist/esm/association/resources.js

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, updateItemWithAuthorization, } from '../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, putItemWithAuthorization, } from '../common/resources/operations.js';
 import { addPaginationToURL } from '../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../common/schema/collection.js';
 import { appendSearchParams } from '../common/schema/url.js';
@@ -35,7 +35,7 @@ export async function listAssociations(instance, id, options, pagination) {
     return PaginationCollectionSchema(AssociationSchema).parse(await getItemWithAuthorization(url, instance.authorizer));
 }
 export async function upsertAssociation(instance, fromId, toId, item) {
-    return AssociationSchema.parse(await updateItemWithAuthorization(new URL(AssociationResources.buildPath(fromId, toId), instance.config.host), instance.authorizer, item ? UpsertAssociationPayloadSchema.parse(item) : undefined));
+    return AssociationSchema.parse(await putItemWithAuthorization(new URL(AssociationResources.buildPath(fromId, toId), instance.config.host), instance.authorizer, item ? UpsertAssociationPayloadSchema.parse(item) : undefined));
 }
 export async function deleteAssociation(instance, fromId, toId) {
     return AssociationSchema.parse(await deleteItemWithAuthorization(new URL(AssociationResources.buildPath(fromId, toId), instance.config.host), instance.authorizer));

package/dist/esm/association/schema.d.ts

@@ -5,17 +5,9 @@ export declare const AssociationObjectType: {
     readonly ROLE: "Role";
     readonly APP: "App";
     readonly PERMISSION: "Permission";
+    readonly SESSION: "Session";
 };
 export type AnyAssociationObjectType = (typeof AssociationObjectType)[keyof typeof AssociationObjectType];
-export declare const AssociationIdReferenceSchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-export type AssociationIdReference = z.output<typeof AssociationIdReferenceSchema>;
-export declare const AssociationAttributesReferenceSchema: z.ZodIntersection<z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-export type AssociationAttributesReference = z.output<typeof AssociationAttributesReferenceSchema>;
-export type AssociationReference = AssociationIdReference | AssociationAttributesReference;
 export declare const AssociationObjectSchema: z.ZodUnion<readonly [z.ZodObject<{
     status: z.ZodDefault<z.ZodEnum<{
         active: "active";
@@ -59,6 +51,19 @@ export declare const AssociationObjectSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>>;
     model: z.ZodLiteral<"Permission">;
     id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    model: z.ZodLiteral<"Session">;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
 }, z.core.$strip>]>;
 export type AssociationObject = z.output<typeof AssociationObjectSchema>;
 export declare const ObjectPropertySchema: z.ZodObject<{
@@ -105,6 +110,19 @@ export declare const ObjectPropertySchema: z.ZodObject<{
         }>>;
         model: z.ZodLiteral<"Permission">;
         id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        model: z.ZodLiteral<"Session">;
+        createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            initiated: "initiated";
+            authenticated: "authenticated";
+        }>;
+        expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+        user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+        userAgent: z.ZodOptional<z.ZodString>;
+        sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
     }, z.core.$strip>]>;
 }, z.core.$strip>;
 export declare const AssociationSchema: z.ZodObject<{
@@ -156,6 +174,19 @@ export declare const AssociationSchema: z.ZodObject<{
         }>>;
         model: z.ZodLiteral<"Permission">;
         id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        model: z.ZodLiteral<"Session">;
+        createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            initiated: "initiated";
+            authenticated: "authenticated";
+        }>;
+        expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+        user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+        userAgent: z.ZodOptional<z.ZodString>;
+        sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
     }, z.core.$strip>]>;
 }, z.core.$strip>;
 declare const RootAssociationProperties: z.ZodObject<{
@@ -229,6 +260,19 @@ export declare const AssociationPayloadSchema: z.ZodObject<{
         }>>;
         model: z.ZodLiteral<"Permission">;
         id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        model: z.ZodLiteral<"Session">;
+        createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            initiated: "initiated";
+            authenticated: "authenticated";
+        }>;
+        expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+        user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+        userAgent: z.ZodOptional<z.ZodString>;
+        sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
     }, z.core.$strip>]>;
 }, z.core.$strip>;
 type RootAssociationPayload = z.output<typeof AssociationPayloadSchema>;

package/dist/esm/association/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/association/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAuB5B,eAAO,MAAM,qBAAqB;;;;;;CAMxB,CAAC;AACX,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAErE,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,oCAAoC;;0DACoB,CAAC;AACtE,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CACnD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B,sBAAsB,GACtB,8BAA8B,CAAC;AAEnC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAMlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAQzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AACH,QAAA,MAAM,yBAAyB;;;;;;iBAA2C,CAAC;AAC3E,KAAK,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC3E,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IAC7C,yBAAyB,GAAG;IAC9B,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AACF,QAAA,MAAM,eAAe;;;;;;iBAA2C,CAAC;AACjE,KAAK,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IACrE,eAAe,GAAG;IAChB,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAEJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOnC,CAAC;AACH,KAAK,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAExE,MAAM,MAAM,kBAAkB,CAC5B,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IAC7C,sBAAsB,GAAG;IAC3B,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,8BAA8B,CACtC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/association/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAwB5B,eAAO,MAAM,qBAAqB;;;;;;;CAOxB,CAAC;AACX,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAErE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAOlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAQzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AACH,QAAA,MAAM,yBAAyB;;;;;;iBAA2C,CAAC;AAC3E,KAAK,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC3E,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IAC7C,yBAAyB,GAAG;IAC9B,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AACF,QAAA,MAAM,eAAe;;;;;;iBAA2C,CAAC;AACjE,KAAK,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IACrE,eAAe,GAAG;IAChB,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAEJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOnC,CAAC;AACH,KAAK,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAExE,MAAM,MAAM,kBAAkB,CAC5B,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IAC7C,sBAAsB,GAAG;IAC3B,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,8BAA8B,CACtC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC"}

package/dist/esm/association/schema.js

@@ -1,5 +1,6 @@
 import * as z from 'zod/v4';
 import { AppAssociationReferenceSchema } from '../app/schema.js';
+import { SessionAssociationReferenceSchema } from '../authentication/sessions/schema.js';
 import { PermissionAssociationReferenceSchema, RoleAssociationReferenceSchema, } from '../authorization/index.js';
 import { DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, OptionalDatePayloadSchema, OptionalDateSchema, UpdatedAtPropertyPayloadSchema, UpdatedAtPropertySchema, } from '../common/schema/dates.js';
 import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../common/schema/metadata.js';
@@ -11,17 +12,15 @@ export const AssociationObjectType = {
     ROLE: 'Role',
     APP: 'App',
     PERMISSION: 'Permission',
+    SESSION: 'Session',
 };
-export const AssociationIdReferenceSchema = z.object({
-    id: z.string(),
-});
-export const AssociationAttributesReferenceSchema = AssociationIdReferenceSchema.and(z.record(z.string(), z.unknown()));
 export const AssociationObjectSchema = z.union([
     UserAssociationReferenceSchema,
     OrganizationAssociationReferenceSchema,
     AppAssociationReferenceSchema,
     RoleAssociationReferenceSchema,
     PermissionAssociationReferenceSchema,
+    SessionAssociationReferenceSchema,
 ]);
 // export type AssociationObject =
 //   | UserAssociationReference

package/dist/esm/association/schema.test.js

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'vitest';
 import { generateAppId } from '../app/utils.js';
 import { generatePermissionId, generateRoleId, } from '../authorization/schema.js';
 import { generateUserId } from '../customer/schema.js';
-import { AssociationObjectType, AssociationIdReferenceSchema, AssociationAttributesReferenceSchema, AssociationObjectSchema, } from './schema.js';
+import { AssociationObjectSchema, AssociationObjectType } from './schema.js';
 describe('Association - Schema', () => {
     describe('AssociationObjectType constants', () => {
         test('should have correct object type values', () => {
@@ -11,56 +11,7 @@ describe('Association - Schema', () => {
             expect(AssociationObjectType.ROLE).toBe('Role');
             expect(AssociationObjectType.APP).toBe('App');
             expect(AssociationObjectType.PERMISSION).toBe('Permission');
-        });
-    });
-    describe('AssociationIdReferenceSchema', () => {
-        test('should accept valid id reference', () => {
-            const reference = { id: 'any_string_id' };
-            const result = AssociationIdReferenceSchema.safeParse(reference);
-            // Parse succeeds for valid data
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toEqual(reference);
-            }
-        });
-        test('should reject missing id', () => {
-            const result = AssociationIdReferenceSchema.safeParse({});
-            expect(result.success).toBe(false);
-        });
-        test('should reject non-string id', () => {
-            const reference = { id: 123 };
-            const result = AssociationIdReferenceSchema.safeParse(reference);
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('AssociationAttributesReferenceSchema', () => {
-        test('should accept id with additional attributes', () => {
-            const reference = {
-                id: 'test_id',
-                name: 'Test Name',
-                status: 'active',
-                metadata: { key: 'value' },
-            };
-            const result = AssociationAttributesReferenceSchema.safeParse(reference);
-            // Parse succeeds for valid data
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toEqual(reference);
-            }
-        });
-        test('should accept minimal reference with just id', () => {
-            const reference = { id: 'minimal_id' };
-            const result = AssociationAttributesReferenceSchema.safeParse(reference);
-            // Parse succeeds for valid data
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toEqual(reference);
-            }
-        });
-        test('should reject missing id', () => {
-            const reference = { name: 'Test', status: 'active' };
-            const result = AssociationAttributesReferenceSchema.safeParse(reference);
-            expect(result.success).toBe(false);
+            expect(AssociationObjectType.SESSION).toBe('Session');
         });
     });
     describe('AssociationObjectSchema', () => {

package/dist/esm/authentication/settings/resources.js

@@ -1,4 +1,4 @@
-import { getItemWithAuthorization, insertItemWithAuthorization, } from '../../common/resources/operations.js';
+import { getItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { PATH } from '../resources.js';
 import { SettingsSchema, UpsertSettingsPayloadSchema, } from './schema.js';
 const RESOURCE = 'settings';
@@ -21,5 +21,5 @@ export async function getSettings(instance) {
     return SettingsSchema.parse(await getItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.config.host), instance.authorizer));
 }
 export async function upsertSettings(instance, item) {
-    return SettingsSchema.parse(await insertItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.config.host), instance.authorizer, UpsertSettingsPayloadSchema.parse(item)));
+    return SettingsSchema.parse(await postItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.config.host), instance.authorizer, UpsertSettingsPayloadSchema.parse(item)));
 }

package/dist/esm/authentication/strategies/resources.js

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, patchItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { addPaginationToURL } from '../../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
 import { PATH } from '../resources.js';
@@ -39,10 +39,10 @@ export async function getStrategy(instance, id) {
     return StrategySchema.parse(await getItemWithAuthorization(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorizer));
 }
 export async function insertStrategy(instance, item) {
-    return StrategySchema.parse(await insertItemWithAuthorization(new URL(StrategyResources.buildPath(), instance.config.host), instance.authorizer, InsertStrategyPayloadSchema.parse(item)));
+    return StrategySchema.parse(await postItemWithAuthorization(new URL(StrategyResources.buildPath(), instance.config.host), instance.authorizer, InsertStrategyPayloadSchema.parse(item)));
 }
 export async function updateStrategy(instance, id, item) {
-    return StrategySchema.parse(await updateItemWithAuthorization(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorizer, UpdateStrategyPayloadSchema.parse(item)));
+    return StrategySchema.parse(await patchItemWithAuthorization(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorizer, UpdateStrategyPayloadSchema.parse(item)));
 }
 export async function deleteStrategy(instance, id) {
     return StrategySchema.parse(await deleteItemWithAuthorization(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorizer));

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

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, patchItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { addPaginationToURL } from '../../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
 import { InsertPermissionPayloadSchema, PermissionSchema, UpdatePermissionPayloadSchema, } from './schema.js';
@@ -38,10 +38,10 @@ export async function getPermission(instance, id) {
     return PermissionSchema.parse(await getItemWithAuthorization(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorizer));
 }
 export async function insertPermission(instance, item) {
-    return PermissionSchema.parse(await insertItemWithAuthorization(new URL(PermissionResources.buildPath(), instance.config.host), instance.authorizer, InsertPermissionPayloadSchema.parse(item)));
+    return PermissionSchema.parse(await postItemWithAuthorization(new URL(PermissionResources.buildPath(), instance.config.host), instance.authorizer, InsertPermissionPayloadSchema.parse(item)));
 }
 export async function updatePermission(instance, id, item) {
-    return PermissionSchema.parse(await updateItemWithAuthorization(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorizer, UpdatePermissionPayloadSchema.parse(item)));
+    return PermissionSchema.parse(await patchItemWithAuthorization(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorizer, UpdatePermissionPayloadSchema.parse(item)));
 }
 export async function deletePermission(instance, id) {
     return PermissionSchema.parse(await deleteItemWithAuthorization(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorizer));

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

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, patchItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { addPaginationToURL } from '../../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
 import { InsertRolePayloadSchema, RoleSchema, UpdateRolePayloadSchema, } from './schema.js';
@@ -38,10 +38,10 @@ export async function getRole(instance, id) {
     return RoleSchema.parse(await getItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer));
 }
 export async function insertRole(instance, item) {
-    return RoleSchema.parse(await insertItemWithAuthorization(new URL(RoleResources.buildPath(), instance.config.host), instance.authorizer, InsertRolePayloadSchema.parse(item)));
+    return RoleSchema.parse(await postItemWithAuthorization(new URL(RoleResources.buildPath(), instance.config.host), instance.authorizer, InsertRolePayloadSchema.parse(item)));
 }
 export async function updateRole(instance, id, item) {
-    return RoleSchema.parse(await updateItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer, UpdateRolePayloadSchema.parse(item)));
+    return RoleSchema.parse(await patchItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer, UpdateRolePayloadSchema.parse(item)));
 }
 export async function deleteRole(instance, id) {
     return RoleSchema.parse(await deleteItemWithAuthorization(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorizer));

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

@@ -1,7 +1,8 @@
 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 patchItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item: Mutation): Promise<Result>;
+export declare function putItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item: Mutation): Promise<Result>;
+export declare function postItemWithAuthorization<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

@@ -1 +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"}
+{"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,0BAA0B,CAAC,MAAM,EAAE,QAAQ,EAC/D,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAC7D,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,MAAM,CAAC,CAEjB;AA8BD,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,QAAQ,EAC9D,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

@@ -17,7 +17,7 @@ export async function listItemsWithAuthorization(url, authorization) {
 }
 export async function getItemWithAuthorization(url, authorization) {
     try {
-        console.debug('Get item', { url });
+        console.debug('GET item', { url });
         const response = await fetch(url, authorization({
             method: 'GET',
             headers: defaultRequestHeaders(),
@@ -31,11 +31,17 @@ export async function getItemWithAuthorization(url, authorization) {
         throw toHttpError(error);
     }
 }
-export async function updateItemWithAuthorization(url, authorization, item) {
+export async function patchItemWithAuthorization(url, authorization, item) {
+    return mutateItemWithAuthorization('PATCH', url, authorization, item);
+}
+export async function putItemWithAuthorization(url, authorization, item) {
+    return mutateItemWithAuthorization('PUT', url, authorization, item);
+}
+async function mutateItemWithAuthorization(method, url, authorization, item) {
     try {
-        console.debug('Update item', { url, item });
+        console.debug(`${method} item`, { url, item });
         const response = await fetch(url, authorization({
-            method: 'PUT',
+            method,
             headers: defaultMutationRequestHeaders(),
             body: JSON.stringify(item),
         }));
@@ -48,9 +54,9 @@ export async function updateItemWithAuthorization(url, authorization, item) {
         throw toHttpError(error);
     }
 }
-export async function insertItemWithAuthorization(url, authorization, item) {
+export async function postItemWithAuthorization(url, authorization, item) {
     try {
-        console.debug('Insert item', { url, item });
+        console.debug('POST item', { url, item });
         const response = await fetch(url, authorization({
             method: 'POST',
             headers: defaultMutationRequestHeaders(),

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

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, test, vi, } from 'vitest';
 import { HttpError } from '../errors/http.js';
 import { ValidationError } from '../errors/validation.js';
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, listItemsWithAuthorization, updateItemWithAuthorization, } from './operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, listItemsWithAuthorization, postItemWithAuthorization, putItemWithAuthorization, } from './operations.js';
 // Mock console.debug to avoid noise in tests
 global.console.debug = vi.fn();
 // Mock fetch globally
@@ -111,7 +111,7 @@ describe('Common Resources - Operations', () => {
                 json: () => Promise.resolve({}),
             });
             await getItemWithAuthorization(testUrl, mockAuthorization);
-            expect(console.debug).toHaveBeenCalledWith('Get item', { url: testUrl });
+            expect(console.debug).toHaveBeenCalledWith('GET item', { url: testUrl });
         });
     });
     describe('updateItemWithAuthorization', () => {
@@ -122,7 +122,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            const result = await putItemWithAuthorization(testUrl, mockAuthorization, updateData);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'PUT',
@@ -136,7 +136,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve({}),
             });
-            await updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            await putItemWithAuthorization(testUrl, mockAuthorization, updateData);
             const authCall = mockAuthorization.mock.calls[0][0];
             const headers = authCall.headers;
             expect(headers.get('accept')).toBe('application/json');
@@ -152,7 +152,7 @@ describe('Common Resources - Operations', () => {
                     fields: { name: ['required'] },
                 }),
             });
-            await expect(updateItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(ValidationError);
+            await expect(putItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(ValidationError);
         });
         test('should log debug information with item data', async () => {
             const updateData = { name: 'Test Item' };
@@ -160,8 +160,8 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve({}),
             });
-            await updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
-            expect(console.debug).toHaveBeenCalledWith('Update item', {
+            await putItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            expect(console.debug).toHaveBeenCalledWith('PUT item', {
                 url: testUrl,
                 item: updateData,
             });
@@ -175,7 +175,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await insertItemWithAuthorization(testUrl, mockAuthorization, insertData);
+            const result = await postItemWithAuthorization(testUrl, mockAuthorization, insertData);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'POST',
@@ -189,7 +189,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await insertItemWithAuthorization(testUrl, mockAuthorization);
+            const result = await postItemWithAuthorization(testUrl, mockAuthorization);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'POST',
@@ -203,7 +203,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await insertItemWithAuthorization(testUrl, mockAuthorization, null);
+            const result = await postItemWithAuthorization(testUrl, mockAuthorization, null);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'POST',
@@ -219,7 +219,7 @@ describe('Common Resources - Operations', () => {
                     error_description: 'Internal server error',
                 }),
             });
-            await expect(insertItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
+            await expect(postItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
         });
         test('should log debug information', async () => {
             const insertData = { name: 'Test' };
@@ -227,8 +227,8 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve({}),
             });
-            await insertItemWithAuthorization(testUrl, mockAuthorization, insertData);
-            expect(console.debug).toHaveBeenCalledWith('Insert item', {
+            await postItemWithAuthorization(testUrl, mockAuthorization, insertData);
+            expect(console.debug).toHaveBeenCalledWith('POST item', {
                 url: testUrl,
                 item: insertData,
             });
@@ -294,8 +294,8 @@ describe('Common Resources - Operations', () => {
             const operations = [
                 () => listItemsWithAuthorization(testUrl, mockAuthorization),
                 () => getItemWithAuthorization(testUrl, mockAuthorization),
-                () => updateItemWithAuthorization(testUrl, mockAuthorization, {}),
-                () => insertItemWithAuthorization(testUrl, mockAuthorization, {}),
+                () => putItemWithAuthorization(testUrl, mockAuthorization, {}),
+                () => postItemWithAuthorization(testUrl, mockAuthorization, {}),
                 () => deleteItemWithAuthorization(testUrl, mockAuthorization),
             ];
             // Mock successful responses for all operations
@@ -348,7 +348,7 @@ describe('Common Resources - Operations', () => {
                 status: 400,
                 json: () => Promise.resolve({}),
             });
-            await expect(updateItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
+            await expect(putItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
         });
     });
 });

package/dist/esm/customer/users/resources.js

@@ -1,4 +1,4 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, listItemsWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { deleteItemWithAuthorization, getItemWithAuthorization, listItemsWithAuthorization, patchItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { addPaginationToURL } from '../../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
 import { InsertUserPayloadSchema, UpdateUserPayloadSchema, UserSchema, } from './schema.js';
@@ -38,10 +38,10 @@ export async function getUser(instance, id) {
     return UserSchema.parse(await getItemWithAuthorization(new URL(UserResources.buildPath(id), instance.config.host), instance.authorizer));
 }
 export async function insertUser(instance, item) {
-    return UserSchema.parse(await insertItemWithAuthorization(new URL(UserResources.buildPath(), instance.config.host), instance.authorizer, InsertUserPayloadSchema.parse(item)));
+    return UserSchema.parse(await postItemWithAuthorization(new URL(UserResources.buildPath(), instance.config.host), instance.authorizer, InsertUserPayloadSchema.parse(item)));
 }
 export async function updateUser(instance, id, item) {
-    return UserSchema.parse(await updateItemWithAuthorization(new URL(UserResources.buildPath(id), instance.config.host), instance.authorizer, UpdateUserPayloadSchema.parse(item)));
+    return UserSchema.parse(await patchItemWithAuthorization(new URL(UserResources.buildPath(id), instance.config.host), instance.authorizer, UpdateUserPayloadSchema.parse(item)));
 }
 export async function deleteUser(instance, id) {
     return UserSchema.parse(await deleteItemWithAuthorization(new URL(UserResources.buildPath(id), instance.config.host), instance.authorizer));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-mondo/identity-sdk",
-  "version": "0.0.2-beta.39",
+  "version": "0.0.2-beta.40",
   "type": "module",
   "description": "A node SDK for Mondo Identity",
   "license": "MIT",