@constructive-io/sdk 0.21.6 → 0.21.7

package/esm/public/orm/models/domain.d.ts

@@ -15,12 +15,10 @@ export declare class DomainModel {
     } & StrictSelect<S, DomainSelect>): QueryBuilder<{
         domains: ConnectionResult<InferSelectResult<DomainWithRelations, S>>;
     }>;
-    findFirst<S extends DomainSelect>(args: FindFirstArgs<S, DomainFilter> & {
+    findFirst<S extends DomainSelect>(args: FindFirstArgs<S, DomainFilter, DomainOrderBy> & {
         select: S;
     } & StrictSelect<S, DomainSelect>): QueryBuilder<{
-        domains: {
-            nodes: InferSelectResult<DomainWithRelations, S>[];
-        };
+        domain: InferSelectResult<DomainWithRelations, S> | null;
     }>;
     findOne<S extends DomainSelect>(args: {
         id: string;

package/esm/public/orm/models/domain.js

@@ -27,14 +27,18 @@ export class DomainModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Domain', 'domains', args.select, {
             where: args?.where,
-        }, 'DomainFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DomainFilter', 'DomainOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Domain',
-            fieldName: 'domains',
+            fieldName: 'domain',
             document,
             variables,
+            transform: (data) => ({
+                domain: data.domains?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/email.d.ts

@@ -15,12 +15,10 @@ export declare class EmailModel {
     } & StrictSelect<S, EmailSelect>): QueryBuilder<{
         emails: ConnectionResult<InferSelectResult<EmailWithRelations, S>>;
     }>;
-    findFirst<S extends EmailSelect>(args: FindFirstArgs<S, EmailFilter> & {
+    findFirst<S extends EmailSelect>(args: FindFirstArgs<S, EmailFilter, EmailOrderBy> & {
         select: S;
     } & StrictSelect<S, EmailSelect>): QueryBuilder<{
-        emails: {
-            nodes: InferSelectResult<EmailWithRelations, S>[];
-        };
+        email: InferSelectResult<EmailWithRelations, S> | null;
     }>;
     findOne<S extends EmailSelect>(args: {
         id: string;

package/esm/public/orm/models/email.js

@@ -27,14 +27,18 @@ export class EmailModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Email', 'emails', args.select, {
             where: args?.where,
-        }, 'EmailFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EmailFilter', 'EmailOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Email',
-            fieldName: 'emails',
+            fieldName: 'email',
             document,
             variables,
+            transform: (data) => ({
+                email: data.emails?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/emailsModule.d.ts

@@ -15,12 +15,10 @@ export declare class EmailsModuleModel {
     } & StrictSelect<S, EmailsModuleSelect>): QueryBuilder<{
         emailsModules: ConnectionResult<InferSelectResult<EmailsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends EmailsModuleSelect>(args: FindFirstArgs<S, EmailsModuleFilter> & {
+    findFirst<S extends EmailsModuleSelect>(args: FindFirstArgs<S, EmailsModuleFilter, EmailsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, EmailsModuleSelect>): QueryBuilder<{
-        emailsModules: {
-            nodes: InferSelectResult<EmailsModuleWithRelations, S>[];
-        };
+        emailsModule: InferSelectResult<EmailsModuleWithRelations, S> | null;
     }>;
     findOne<S extends EmailsModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/emailsModule.js

@@ -27,14 +27,18 @@ export class EmailsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EmailsModule', 'emailsModules', args.select, {
             where: args?.where,
-        }, 'EmailsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EmailsModuleFilter', 'EmailsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EmailsModule',
-            fieldName: 'emailsModules',
+            fieldName: 'emailsModule',
             document,
             variables,
+            transform: (data) => ({
+                emailsModule: data.emailsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/embeddingChunk.d.ts

@@ -15,12 +15,10 @@ export declare class EmbeddingChunkModel {
     } & StrictSelect<S, EmbeddingChunkSelect>): QueryBuilder<{
         embeddingChunks: ConnectionResult<InferSelectResult<EmbeddingChunkWithRelations, S>>;
     }>;
-    findFirst<S extends EmbeddingChunkSelect>(args: FindFirstArgs<S, EmbeddingChunkFilter> & {
+    findFirst<S extends EmbeddingChunkSelect>(args: FindFirstArgs<S, EmbeddingChunkFilter, EmbeddingChunkOrderBy> & {
         select: S;
     } & StrictSelect<S, EmbeddingChunkSelect>): QueryBuilder<{
-        embeddingChunks: {
-            nodes: InferSelectResult<EmbeddingChunkWithRelations, S>[];
-        };
+        embeddingChunk: InferSelectResult<EmbeddingChunkWithRelations, S> | null;
     }>;
     findOne<S extends EmbeddingChunkSelect>(args: {
         id: string;

package/esm/public/orm/models/embeddingChunk.js

@@ -27,14 +27,18 @@ export class EmbeddingChunkModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EmbeddingChunk', 'embeddingChunks', args.select, {
             where: args?.where,
-        }, 'EmbeddingChunkFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EmbeddingChunkFilter', 'EmbeddingChunkOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EmbeddingChunk',
-            fieldName: 'embeddingChunks',
+            fieldName: 'embeddingChunk',
             document,
             variables,
+            transform: (data) => ({
+                embeddingChunk: data.embeddingChunks?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/encryptedSecretsModule.d.ts

@@ -15,12 +15,10 @@ export declare class EncryptedSecretsModuleModel {
     } & StrictSelect<S, EncryptedSecretsModuleSelect>): QueryBuilder<{
         encryptedSecretsModules: ConnectionResult<InferSelectResult<EncryptedSecretsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends EncryptedSecretsModuleSelect>(args: FindFirstArgs<S, EncryptedSecretsModuleFilter> & {
+    findFirst<S extends EncryptedSecretsModuleSelect>(args: FindFirstArgs<S, EncryptedSecretsModuleFilter, EncryptedSecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, EncryptedSecretsModuleSelect>): QueryBuilder<{
-        encryptedSecretsModules: {
-            nodes: InferSelectResult<EncryptedSecretsModuleWithRelations, S>[];
-        };
+        encryptedSecretsModule: InferSelectResult<EncryptedSecretsModuleWithRelations, S> | null;
     }>;
     findOne<S extends EncryptedSecretsModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/encryptedSecretsModule.js

@@ -27,14 +27,18 @@ export class EncryptedSecretsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EncryptedSecretsModule', 'encryptedSecretsModules', args.select, {
             where: args?.where,
-        }, 'EncryptedSecretsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EncryptedSecretsModuleFilter', 'EncryptedSecretsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EncryptedSecretsModule',
-            fieldName: 'encryptedSecretsModules',
+            fieldName: 'encryptedSecretsModule',
             document,
             variables,
+            transform: (data) => ({
+                encryptedSecretsModule: data.encryptedSecretsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/entityTypeProvision.d.ts

@@ -15,12 +15,10 @@ export declare class EntityTypeProvisionModel {
     } & StrictSelect<S, EntityTypeProvisionSelect>): QueryBuilder<{
         entityTypeProvisions: ConnectionResult<InferSelectResult<EntityTypeProvisionWithRelations, S>>;
     }>;
-    findFirst<S extends EntityTypeProvisionSelect>(args: FindFirstArgs<S, EntityTypeProvisionFilter> & {
+    findFirst<S extends EntityTypeProvisionSelect>(args: FindFirstArgs<S, EntityTypeProvisionFilter, EntityTypeProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, EntityTypeProvisionSelect>): QueryBuilder<{
-        entityTypeProvisions: {
-            nodes: InferSelectResult<EntityTypeProvisionWithRelations, S>[];
-        };
+        entityTypeProvision: InferSelectResult<EntityTypeProvisionWithRelations, S> | null;
     }>;
     findOne<S extends EntityTypeProvisionSelect>(args: {
         id: string;

package/esm/public/orm/models/entityTypeProvision.js

@@ -27,14 +27,18 @@ export class EntityTypeProvisionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EntityTypeProvision', 'entityTypeProvisions', args.select, {
             where: args?.where,
-        }, 'EntityTypeProvisionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EntityTypeProvisionFilter', 'EntityTypeProvisionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EntityTypeProvision',
-            fieldName: 'entityTypeProvisions',
+            fieldName: 'entityTypeProvision',
             document,
             variables,
+            transform: (data) => ({
+                entityTypeProvision: data.entityTypeProvisions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/enum.d.ts

@@ -15,12 +15,10 @@ export declare class EnumModel {
     } & StrictSelect<S, EnumSelect>): QueryBuilder<{
         enums: ConnectionResult<InferSelectResult<EnumWithRelations, S>>;
     }>;
-    findFirst<S extends EnumSelect>(args: FindFirstArgs<S, EnumFilter> & {
+    findFirst<S extends EnumSelect>(args: FindFirstArgs<S, EnumFilter, EnumOrderBy> & {
         select: S;
     } & StrictSelect<S, EnumSelect>): QueryBuilder<{
-        enums: {
-            nodes: InferSelectResult<EnumWithRelations, S>[];
-        };
+        enum: InferSelectResult<EnumWithRelations, S> | null;
     }>;
     findOne<S extends EnumSelect>(args: {
         id: string;

package/esm/public/orm/models/enum.js

@@ -27,14 +27,18 @@ export class EnumModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Enum', 'enums', args.select, {
             where: args?.where,
-        }, 'EnumFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EnumFilter', 'EnumOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Enum',
-            fieldName: 'enums',
+            fieldName: 'enum',
             document,
             variables,
+            transform: (data) => ({
+                enum: data.enums?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/field.d.ts

@@ -15,12 +15,10 @@ export declare class FieldModel {
     } & StrictSelect<S, FieldSelect>): QueryBuilder<{
         fields: ConnectionResult<InferSelectResult<FieldWithRelations, S>>;
     }>;
-    findFirst<S extends FieldSelect>(args: FindFirstArgs<S, FieldFilter> & {
+    findFirst<S extends FieldSelect>(args: FindFirstArgs<S, FieldFilter, FieldOrderBy> & {
         select: S;
     } & StrictSelect<S, FieldSelect>): QueryBuilder<{
-        fields: {
-            nodes: InferSelectResult<FieldWithRelations, S>[];
-        };
+        field: InferSelectResult<FieldWithRelations, S> | null;
     }>;
     findOne<S extends FieldSelect>(args: {
         id: string;

package/esm/public/orm/models/field.js

@@ -27,14 +27,18 @@ export class FieldModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Field', 'fields', args.select, {
             where: args?.where,
-        }, 'FieldFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'FieldFilter', 'FieldOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Field',
-            fieldName: 'fields',
+            fieldName: 'field',
             document,
             variables,
+            transform: (data) => ({
+                field: data.fields?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/foreignKeyConstraint.d.ts

@@ -15,12 +15,10 @@ export declare class ForeignKeyConstraintModel {
     } & StrictSelect<S, ForeignKeyConstraintSelect>): QueryBuilder<{
         foreignKeyConstraints: ConnectionResult<InferSelectResult<ForeignKeyConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends ForeignKeyConstraintSelect>(args: FindFirstArgs<S, ForeignKeyConstraintFilter> & {
+    findFirst<S extends ForeignKeyConstraintSelect>(args: FindFirstArgs<S, ForeignKeyConstraintFilter, ForeignKeyConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, ForeignKeyConstraintSelect>): QueryBuilder<{
-        foreignKeyConstraints: {
-            nodes: InferSelectResult<ForeignKeyConstraintWithRelations, S>[];
-        };
+        foreignKeyConstraint: InferSelectResult<ForeignKeyConstraintWithRelations, S> | null;
     }>;
     findOne<S extends ForeignKeyConstraintSelect>(args: {
         id: string;

package/esm/public/orm/models/foreignKeyConstraint.js

@@ -27,14 +27,18 @@ export class ForeignKeyConstraintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ForeignKeyConstraint', 'foreignKeyConstraints', args.select, {
             where: args?.where,
-        }, 'ForeignKeyConstraintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ForeignKeyConstraintFilter', 'ForeignKeyConstraintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ForeignKeyConstraint',
-            fieldName: 'foreignKeyConstraints',
+            fieldName: 'foreignKeyConstraint',
             document,
             variables,
+            transform: (data) => ({
+                foreignKeyConstraint: data.foreignKeyConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/fullTextSearch.d.ts

@@ -15,12 +15,10 @@ export declare class FullTextSearchModel {
     } & StrictSelect<S, FullTextSearchSelect>): QueryBuilder<{
         fullTextSearches: ConnectionResult<InferSelectResult<FullTextSearchWithRelations, S>>;
     }>;
-    findFirst<S extends FullTextSearchSelect>(args: FindFirstArgs<S, FullTextSearchFilter> & {
+    findFirst<S extends FullTextSearchSelect>(args: FindFirstArgs<S, FullTextSearchFilter, FullTextSearchOrderBy> & {
         select: S;
     } & StrictSelect<S, FullTextSearchSelect>): QueryBuilder<{
-        fullTextSearches: {
-            nodes: InferSelectResult<FullTextSearchWithRelations, S>[];
-        };
+        fullTextSearch: InferSelectResult<FullTextSearchWithRelations, S> | null;
     }>;
     findOne<S extends FullTextSearchSelect>(args: {
         id: string;

package/esm/public/orm/models/fullTextSearch.js

@@ -27,14 +27,18 @@ export class FullTextSearchModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('FullTextSearch', 'fullTextSearches', args.select, {
             where: args?.where,
-        }, 'FullTextSearchFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'FullTextSearchFilter', 'FullTextSearchOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'FullTextSearch',
-            fieldName: 'fullTextSearches',
+            fieldName: 'fullTextSearch',
             document,
             variables,
+            transform: (data) => ({
+                fullTextSearch: data.fullTextSearches?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/function.d.ts

@@ -15,12 +15,10 @@ export declare class FunctionModel {
     } & StrictSelect<S, FunctionSelect>): QueryBuilder<{
         functions: ConnectionResult<InferSelectResult<FunctionWithRelations, S>>;
     }>;
-    findFirst<S extends FunctionSelect>(args: FindFirstArgs<S, FunctionFilter> & {
+    findFirst<S extends FunctionSelect>(args: FindFirstArgs<S, FunctionFilter, FunctionOrderBy> & {
         select: S;
     } & StrictSelect<S, FunctionSelect>): QueryBuilder<{
-        functions: {
-            nodes: InferSelectResult<FunctionWithRelations, S>[];
-        };
+        function: InferSelectResult<FunctionWithRelations, S> | null;
     }>;
     findOne<S extends FunctionSelect>(args: {
         id: string;

package/esm/public/orm/models/function.js

@@ -27,14 +27,18 @@ export class FunctionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Function', 'functions', args.select, {
             where: args?.where,
-        }, 'FunctionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'FunctionFilter', 'FunctionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Function',
-            fieldName: 'functions',
+            fieldName: 'function',
             document,
             variables,
+            transform: (data) => ({
+                function: data.functions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/getAllRecord.d.ts

@@ -15,12 +15,10 @@ export declare class GetAllRecordModel {
     } & StrictSelect<S, GetAllRecordSelect>): QueryBuilder<{
         getAll: ConnectionResult<InferSelectResult<GetAllRecordWithRelations, S>>;
     }>;
-    findFirst<S extends GetAllRecordSelect>(args: FindFirstArgs<S, GetAllRecordFilter> & {
+    findFirst<S extends GetAllRecordSelect>(args: FindFirstArgs<S, GetAllRecordFilter, GetAllRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, GetAllRecordSelect>): QueryBuilder<{
-        getAll: {
-            nodes: InferSelectResult<GetAllRecordWithRelations, S>[];
-        };
+        getAllRecord: InferSelectResult<GetAllRecordWithRelations, S> | null;
     }>;
     create<S extends GetAllRecordSelect>(args: CreateArgs<S, CreateGetAllRecordInput['getAllRecord']> & {
         select: S;

package/esm/public/orm/models/getAllRecord.js

@@ -27,14 +27,18 @@ export class GetAllRecordModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('GetAllRecord', 'getAll', args.select, {
             where: args?.where,
-        }, 'GetAllRecordFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'GetAllRecordFilter', 'GetAllRecordsOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'GetAllRecord',
-            fieldName: 'getAll',
+            fieldName: 'getAllRecord',
             document,
             variables,
+            transform: (data) => ({
+                getAllRecord: data.getAll?.nodes?.[0] ?? null,
+            }),
         });
     }
     create(args) {

package/esm/public/orm/models/hierarchyModule.d.ts

@@ -15,12 +15,10 @@ export declare class HierarchyModuleModel {
     } & StrictSelect<S, HierarchyModuleSelect>): QueryBuilder<{
         hierarchyModules: ConnectionResult<InferSelectResult<HierarchyModuleWithRelations, S>>;
     }>;
-    findFirst<S extends HierarchyModuleSelect>(args: FindFirstArgs<S, HierarchyModuleFilter> & {
+    findFirst<S extends HierarchyModuleSelect>(args: FindFirstArgs<S, HierarchyModuleFilter, HierarchyModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, HierarchyModuleSelect>): QueryBuilder<{
-        hierarchyModules: {
-            nodes: InferSelectResult<HierarchyModuleWithRelations, S>[];
-        };
+        hierarchyModule: InferSelectResult<HierarchyModuleWithRelations, S> | null;
     }>;
     findOne<S extends HierarchyModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/hierarchyModule.js

@@ -27,14 +27,18 @@ export class HierarchyModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('HierarchyModule', 'hierarchyModules', args.select, {
             where: args?.where,
-        }, 'HierarchyModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'HierarchyModuleFilter', 'HierarchyModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'HierarchyModule',
-            fieldName: 'hierarchyModules',
+            fieldName: 'hierarchyModule',
             document,
             variables,
+            transform: (data) => ({
+                hierarchyModule: data.hierarchyModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/identityProvider.d.ts

@@ -15,12 +15,10 @@ export declare class IdentityProviderModel {
     } & StrictSelect<S, IdentityProviderSelect>): QueryBuilder<{
         identityProviders: ConnectionResult<InferSelectResult<IdentityProviderWithRelations, S>>;
     }>;
-    findFirst<S extends IdentityProviderSelect>(args: FindFirstArgs<S, IdentityProviderFilter> & {
+    findFirst<S extends IdentityProviderSelect>(args: FindFirstArgs<S, IdentityProviderFilter, IdentityProviderOrderBy> & {
         select: S;
     } & StrictSelect<S, IdentityProviderSelect>): QueryBuilder<{
-        identityProviders: {
-            nodes: InferSelectResult<IdentityProviderWithRelations, S>[];
-        };
+        identityProvider: InferSelectResult<IdentityProviderWithRelations, S> | null;
     }>;
     create<S extends IdentityProviderSelect>(args: CreateArgs<S, CreateIdentityProviderInput['identityProvider']> & {
         select: S;

package/esm/public/orm/models/identityProvider.js

@@ -27,14 +27,18 @@ export class IdentityProviderModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('IdentityProvider', 'identityProviders', args.select, {
             where: args?.where,
-        }, 'IdentityProviderFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'IdentityProviderFilter', 'IdentityProviderOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'IdentityProvider',
-            fieldName: 'identityProviders',
+            fieldName: 'identityProvider',
             document,
             variables,
+            transform: (data) => ({
+                identityProvider: data.identityProviders?.nodes?.[0] ?? null,
+            }),
         });
     }
     create(args) {

package/esm/public/orm/models/identityProvidersModule.d.ts

@@ -15,12 +15,10 @@ export declare class IdentityProvidersModuleModel {
     } & StrictSelect<S, IdentityProvidersModuleSelect>): QueryBuilder<{
         identityProvidersModules: ConnectionResult<InferSelectResult<IdentityProvidersModuleWithRelations, S>>;
     }>;
-    findFirst<S extends IdentityProvidersModuleSelect>(args: FindFirstArgs<S, IdentityProvidersModuleFilter> & {
+    findFirst<S extends IdentityProvidersModuleSelect>(args: FindFirstArgs<S, IdentityProvidersModuleFilter, IdentityProvidersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, IdentityProvidersModuleSelect>): QueryBuilder<{
-        identityProvidersModules: {
-            nodes: InferSelectResult<IdentityProvidersModuleWithRelations, S>[];
-        };
+        identityProvidersModule: InferSelectResult<IdentityProvidersModuleWithRelations, S> | null;
     }>;
     findOne<S extends IdentityProvidersModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/identityProvidersModule.js

@@ -27,14 +27,18 @@ export class IdentityProvidersModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('IdentityProvidersModule', 'identityProvidersModules', args.select, {
             where: args?.where,
-        }, 'IdentityProvidersModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'IdentityProvidersModuleFilter', 'IdentityProvidersModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'IdentityProvidersModule',
-            fieldName: 'identityProvidersModules',
+            fieldName: 'identityProvidersModule',
             document,
             variables,
+            transform: (data) => ({
+                identityProvidersModule: data.identityProvidersModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/indexModel.d.ts

@@ -15,12 +15,10 @@ export declare class IndexModel {
     } & StrictSelect<S, IndexSelect>): QueryBuilder<{
         indices: ConnectionResult<InferSelectResult<IndexWithRelations, S>>;
     }>;
-    findFirst<S extends IndexSelect>(args: FindFirstArgs<S, IndexFilter> & {
+    findFirst<S extends IndexSelect>(args: FindFirstArgs<S, IndexFilter, IndexOrderBy> & {
         select: S;
     } & StrictSelect<S, IndexSelect>): QueryBuilder<{
-        indices: {
-            nodes: InferSelectResult<IndexWithRelations, S>[];
-        };
+        index: InferSelectResult<IndexWithRelations, S> | null;
     }>;
     findOne<S extends IndexSelect>(args: {
         id: string;

package/esm/public/orm/models/indexModel.js

@@ -27,14 +27,18 @@ export class IndexModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Index', 'indices', args.select, {
             where: args?.where,
-        }, 'IndexFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'IndexFilter', 'IndexOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Index',
-            fieldName: 'indices',
+            fieldName: 'index',
             document,
             variables,
+            transform: (data) => ({
+                index: data.indices?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/invitesModule.d.ts

@@ -15,12 +15,10 @@ export declare class InvitesModuleModel {
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
         invitesModules: ConnectionResult<InferSelectResult<InvitesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter> & {
+    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter, InvitesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
-        invitesModules: {
-            nodes: InferSelectResult<InvitesModuleWithRelations, S>[];
-        };
+        invitesModule: InferSelectResult<InvitesModuleWithRelations, S> | null;
     }>;
     findOne<S extends InvitesModuleSelect>(args: {
         id: string;