@constructive-io/react 0.19.6 → 0.19.8

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

@@ -27,14 +27,18 @@ export class BlueprintConstructionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('BlueprintConstruction', 'blueprintConstructions', args.select, {
             where: args?.where,
-        }, 'BlueprintConstructionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintConstructionFilter', 'BlueprintConstructionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BlueprintConstruction',
-            fieldName: 'blueprintConstructions',
+            fieldName: 'blueprintConstruction',
             document,
             variables,
+            transform: (data) => ({
+                blueprintConstruction: data.blueprintConstructions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BlueprintTemplateModel {
     } & StrictSelect<S, BlueprintTemplateSelect>): QueryBuilder<{
         blueprintTemplates: ConnectionResult<InferSelectResult<BlueprintTemplateWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintTemplateSelect>(args: FindFirstArgs<S, BlueprintTemplateFilter> & {
+    findFirst<S extends BlueprintTemplateSelect>(args: FindFirstArgs<S, BlueprintTemplateFilter, BlueprintTemplateOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintTemplateSelect>): QueryBuilder<{
-        blueprintTemplates: {
-            nodes: InferSelectResult<BlueprintTemplateWithRelations, S>[];
-        };
+        blueprintTemplate: InferSelectResult<BlueprintTemplateWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintTemplateSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class BlueprintTemplateModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('BlueprintTemplate', 'blueprintTemplates', args.select, {
             where: args?.where,
-        }, 'BlueprintTemplateFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintTemplateFilter', 'BlueprintTemplateOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BlueprintTemplate',
-            fieldName: 'blueprintTemplates',
+            fieldName: 'blueprintTemplate',
             document,
             variables,
+            transform: (data) => ({
+                blueprintTemplate: data.blueprintTemplates?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CheckConstraintModel {
     } & StrictSelect<S, CheckConstraintSelect>): QueryBuilder<{
         checkConstraints: ConnectionResult<InferSelectResult<CheckConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends CheckConstraintSelect>(args: FindFirstArgs<S, CheckConstraintFilter> & {
+    findFirst<S extends CheckConstraintSelect>(args: FindFirstArgs<S, CheckConstraintFilter, CheckConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, CheckConstraintSelect>): QueryBuilder<{
-        checkConstraints: {
-            nodes: InferSelectResult<CheckConstraintWithRelations, S>[];
-        };
+        checkConstraint: InferSelectResult<CheckConstraintWithRelations, S> | null;
     }>;
     findOne<S extends CheckConstraintSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CheckConstraintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CheckConstraint', 'checkConstraints', args.select, {
             where: args?.where,
-        }, 'CheckConstraintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CheckConstraintFilter', 'CheckConstraintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CheckConstraint',
-            fieldName: 'checkConstraints',
+            fieldName: 'checkConstraint',
             document,
             variables,
+            transform: (data) => ({
+                checkConstraint: data.checkConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CommitModel {
     } & StrictSelect<S, CommitSelect>): QueryBuilder<{
         commits: ConnectionResult<InferSelectResult<CommitWithRelations, S>>;
     }>;
-    findFirst<S extends CommitSelect>(args: FindFirstArgs<S, CommitFilter> & {
+    findFirst<S extends CommitSelect>(args: FindFirstArgs<S, CommitFilter, CommitOrderBy> & {
         select: S;
     } & StrictSelect<S, CommitSelect>): QueryBuilder<{
-        commits: {
-            nodes: InferSelectResult<CommitWithRelations, S>[];
-        };
+        commit: InferSelectResult<CommitWithRelations, S> | null;
     }>;
     findOne<S extends CommitSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CommitModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Commit', 'commits', args.select, {
             where: args?.where,
-        }, 'CommitFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CommitFilter', 'CommitOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Commit',
-            fieldName: 'commits',
+            fieldName: 'commit',
             document,
             variables,
+            transform: (data) => ({
+                commit: data.commits?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class ConnectedAccountsModuleModel {
     } & StrictSelect<S, ConnectedAccountsModuleSelect>): QueryBuilder<{
         connectedAccountsModules: ConnectionResult<InferSelectResult<ConnectedAccountsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends ConnectedAccountsModuleSelect>(args: FindFirstArgs<S, ConnectedAccountsModuleFilter> & {
+    findFirst<S extends ConnectedAccountsModuleSelect>(args: FindFirstArgs<S, ConnectedAccountsModuleFilter, ConnectedAccountsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ConnectedAccountsModuleSelect>): QueryBuilder<{
-        connectedAccountsModules: {
-            nodes: InferSelectResult<ConnectedAccountsModuleWithRelations, S>[];
-        };
+        connectedAccountsModule: InferSelectResult<ConnectedAccountsModuleWithRelations, S> | null;
     }>;
     findOne<S extends ConnectedAccountsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class ConnectedAccountsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ConnectedAccountsModule', 'connectedAccountsModules', args.select, {
             where: args?.where,
-        }, 'ConnectedAccountsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ConnectedAccountsModuleFilter', 'ConnectedAccountsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ConnectedAccountsModule',
-            fieldName: 'connectedAccountsModules',
+            fieldName: 'connectedAccountsModule',
             document,
             variables,
+            transform: (data) => ({
+                connectedAccountsModule: data.connectedAccountsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CorsSettingModel {
     } & StrictSelect<S, CorsSettingSelect>): QueryBuilder<{
         corsSettings: ConnectionResult<InferSelectResult<CorsSettingWithRelations, S>>;
     }>;
-    findFirst<S extends CorsSettingSelect>(args: FindFirstArgs<S, CorsSettingFilter> & {
+    findFirst<S extends CorsSettingSelect>(args: FindFirstArgs<S, CorsSettingFilter, CorsSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, CorsSettingSelect>): QueryBuilder<{
-        corsSettings: {
-            nodes: InferSelectResult<CorsSettingWithRelations, S>[];
-        };
+        corsSetting: InferSelectResult<CorsSettingWithRelations, S> | null;
     }>;
     findOne<S extends CorsSettingSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CorsSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CorsSetting', 'corsSettings', args.select, {
             where: args?.where,
-        }, 'CorsSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CorsSettingFilter', 'CorsSettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CorsSetting',
-            fieldName: 'corsSettings',
+            fieldName: 'corsSetting',
             document,
             variables,
+            transform: (data) => ({
+                corsSetting: data.corsSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CryptoAddressModel {
     } & StrictSelect<S, CryptoAddressSelect>): QueryBuilder<{
         cryptoAddresses: ConnectionResult<InferSelectResult<CryptoAddressWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAddressSelect>(args: FindFirstArgs<S, CryptoAddressFilter> & {
+    findFirst<S extends CryptoAddressSelect>(args: FindFirstArgs<S, CryptoAddressFilter, CryptoAddressOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAddressSelect>): QueryBuilder<{
-        cryptoAddresses: {
-            nodes: InferSelectResult<CryptoAddressWithRelations, S>[];
-        };
+        cryptoAddress: InferSelectResult<CryptoAddressWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAddressSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CryptoAddressModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CryptoAddress', 'cryptoAddresses', args.select, {
             where: args?.where,
-        }, 'CryptoAddressFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAddressFilter', 'CryptoAddressOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAddress',
-            fieldName: 'cryptoAddresses',
+            fieldName: 'cryptoAddress',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAddress: data.cryptoAddresses?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CryptoAddressesModuleModel {
     } & StrictSelect<S, CryptoAddressesModuleSelect>): QueryBuilder<{
         cryptoAddressesModules: ConnectionResult<InferSelectResult<CryptoAddressesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAddressesModuleSelect>(args: FindFirstArgs<S, CryptoAddressesModuleFilter> & {
+    findFirst<S extends CryptoAddressesModuleSelect>(args: FindFirstArgs<S, CryptoAddressesModuleFilter, CryptoAddressesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAddressesModuleSelect>): QueryBuilder<{
-        cryptoAddressesModules: {
-            nodes: InferSelectResult<CryptoAddressesModuleWithRelations, S>[];
-        };
+        cryptoAddressesModule: InferSelectResult<CryptoAddressesModuleWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAddressesModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CryptoAddressesModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CryptoAddressesModule', 'cryptoAddressesModules', args.select, {
             where: args?.where,
-        }, 'CryptoAddressesModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAddressesModuleFilter', 'CryptoAddressesModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAddressesModule',
-            fieldName: 'cryptoAddressesModules',
+            fieldName: 'cryptoAddressesModule',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAddressesModule: data.cryptoAddressesModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CryptoAuthModuleModel {
     } & StrictSelect<S, CryptoAuthModuleSelect>): QueryBuilder<{
         cryptoAuthModules: ConnectionResult<InferSelectResult<CryptoAuthModuleWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAuthModuleSelect>(args: FindFirstArgs<S, CryptoAuthModuleFilter> & {
+    findFirst<S extends CryptoAuthModuleSelect>(args: FindFirstArgs<S, CryptoAuthModuleFilter, CryptoAuthModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAuthModuleSelect>): QueryBuilder<{
-        cryptoAuthModules: {
-            nodes: InferSelectResult<CryptoAuthModuleWithRelations, S>[];
-        };
+        cryptoAuthModule: InferSelectResult<CryptoAuthModuleWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAuthModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CryptoAuthModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CryptoAuthModule', 'cryptoAuthModules', args.select, {
             where: args?.where,
-        }, 'CryptoAuthModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAuthModuleFilter', 'CryptoAuthModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAuthModule',
-            fieldName: 'cryptoAuthModules',
+            fieldName: 'cryptoAuthModule',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAuthModule: data.cryptoAuthModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseModel {
     } & StrictSelect<S, DatabaseSelect>): QueryBuilder<{
         databases: ConnectionResult<InferSelectResult<DatabaseWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseSelect>(args: FindFirstArgs<S, DatabaseFilter> & {
+    findFirst<S extends DatabaseSelect>(args: FindFirstArgs<S, DatabaseFilter, DatabaseOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseSelect>): QueryBuilder<{
-        databases: {
-            nodes: InferSelectResult<DatabaseWithRelations, S>[];
-        };
+        database: InferSelectResult<DatabaseWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Database', 'databases', args.select, {
             where: args?.where,
-        }, 'DatabaseFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseFilter', 'DatabaseOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Database',
-            fieldName: 'databases',
+            fieldName: 'database',
             document,
             variables,
+            transform: (data) => ({
+                database: data.databases?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseProvisionModuleModel {
     } & StrictSelect<S, DatabaseProvisionModuleSelect>): QueryBuilder<{
         databaseProvisionModules: ConnectionResult<InferSelectResult<DatabaseProvisionModuleWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseProvisionModuleSelect>(args: FindFirstArgs<S, DatabaseProvisionModuleFilter> & {
+    findFirst<S extends DatabaseProvisionModuleSelect>(args: FindFirstArgs<S, DatabaseProvisionModuleFilter, DatabaseProvisionModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseProvisionModuleSelect>): QueryBuilder<{
-        databaseProvisionModules: {
-            nodes: InferSelectResult<DatabaseProvisionModuleWithRelations, S>[];
-        };
+        databaseProvisionModule: InferSelectResult<DatabaseProvisionModuleWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseProvisionModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseProvisionModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DatabaseProvisionModule', 'databaseProvisionModules', args.select, {
             where: args?.where,
-        }, 'DatabaseProvisionModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseProvisionModuleFilter', 'DatabaseProvisionModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DatabaseProvisionModule',
-            fieldName: 'databaseProvisionModules',
+            fieldName: 'databaseProvisionModule',
             document,
             variables,
+            transform: (data) => ({
+                databaseProvisionModule: data.databaseProvisionModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseSettingModel {
     } & StrictSelect<S, DatabaseSettingSelect>): QueryBuilder<{
         databaseSettings: ConnectionResult<InferSelectResult<DatabaseSettingWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseSettingSelect>(args: FindFirstArgs<S, DatabaseSettingFilter> & {
+    findFirst<S extends DatabaseSettingSelect>(args: FindFirstArgs<S, DatabaseSettingFilter, DatabaseSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseSettingSelect>): QueryBuilder<{
-        databaseSettings: {
-            nodes: InferSelectResult<DatabaseSettingWithRelations, S>[];
-        };
+        databaseSetting: InferSelectResult<DatabaseSettingWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseSettingSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DatabaseSetting', 'databaseSettings', args.select, {
             where: args?.where,
-        }, 'DatabaseSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseSettingFilter', 'DatabaseSettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DatabaseSetting',
-            fieldName: 'databaseSettings',
+            fieldName: 'databaseSetting',
             document,
             variables,
+            transform: (data) => ({
+                databaseSetting: data.databaseSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseTransferModel {
     } & StrictSelect<S, DatabaseTransferSelect>): QueryBuilder<{
         databaseTransfers: ConnectionResult<InferSelectResult<DatabaseTransferWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseTransferSelect>(args: FindFirstArgs<S, DatabaseTransferFilter> & {
+    findFirst<S extends DatabaseTransferSelect>(args: FindFirstArgs<S, DatabaseTransferFilter, DatabaseTransferOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseTransferSelect>): QueryBuilder<{
-        databaseTransfers: {
-            nodes: InferSelectResult<DatabaseTransferWithRelations, S>[];
-        };
+        databaseTransfer: InferSelectResult<DatabaseTransferWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseTransferSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseTransferModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DatabaseTransfer', 'databaseTransfers', args.select, {
             where: args?.where,
-        }, 'DatabaseTransferFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseTransferFilter', 'DatabaseTransferOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DatabaseTransfer',
-            fieldName: 'databaseTransfers',
+            fieldName: 'databaseTransfer',
             document,
             variables,
+            transform: (data) => ({
+                databaseTransfer: data.databaseTransfers?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DefaultIdsModuleModel {
     } & StrictSelect<S, DefaultIdsModuleSelect>): QueryBuilder<{
         defaultIdsModules: ConnectionResult<InferSelectResult<DefaultIdsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends DefaultIdsModuleSelect>(args: FindFirstArgs<S, DefaultIdsModuleFilter> & {
+    findFirst<S extends DefaultIdsModuleSelect>(args: FindFirstArgs<S, DefaultIdsModuleFilter, DefaultIdsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DefaultIdsModuleSelect>): QueryBuilder<{
-        defaultIdsModules: {
-            nodes: InferSelectResult<DefaultIdsModuleWithRelations, S>[];
-        };
+        defaultIdsModule: InferSelectResult<DefaultIdsModuleWithRelations, S> | null;
     }>;
     findOne<S extends DefaultIdsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DefaultIdsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DefaultIdsModule', 'defaultIdsModules', args.select, {
             where: args?.where,
-        }, 'DefaultIdsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DefaultIdsModuleFilter', 'DefaultIdsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DefaultIdsModule',
-            fieldName: 'defaultIdsModules',
+            fieldName: 'defaultIdsModule',
             document,
             variables,
+            transform: (data) => ({
+                defaultIdsModule: data.defaultIdsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DefaultPrivilegeModel {
     } & StrictSelect<S, DefaultPrivilegeSelect>): QueryBuilder<{
         defaultPrivileges: ConnectionResult<InferSelectResult<DefaultPrivilegeWithRelations, S>>;
     }>;
-    findFirst<S extends DefaultPrivilegeSelect>(args: FindFirstArgs<S, DefaultPrivilegeFilter> & {
+    findFirst<S extends DefaultPrivilegeSelect>(args: FindFirstArgs<S, DefaultPrivilegeFilter, DefaultPrivilegeOrderBy> & {
         select: S;
     } & StrictSelect<S, DefaultPrivilegeSelect>): QueryBuilder<{
-        defaultPrivileges: {
-            nodes: InferSelectResult<DefaultPrivilegeWithRelations, S>[];
-        };
+        defaultPrivilege: InferSelectResult<DefaultPrivilegeWithRelations, S> | null;
     }>;
     findOne<S extends DefaultPrivilegeSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DefaultPrivilegeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DefaultPrivilege', 'defaultPrivileges', args.select, {
             where: args?.where,
-        }, 'DefaultPrivilegeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DefaultPrivilegeFilter', 'DefaultPrivilegeOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DefaultPrivilege',
-            fieldName: 'defaultPrivileges',
+            fieldName: 'defaultPrivilege',
             document,
             variables,
+            transform: (data) => ({
+                defaultPrivilege: data.defaultPrivileges?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DenormalizedTableFieldModel {
     } & StrictSelect<S, DenormalizedTableFieldSelect>): QueryBuilder<{
         denormalizedTableFields: ConnectionResult<InferSelectResult<DenormalizedTableFieldWithRelations, S>>;
     }>;
-    findFirst<S extends DenormalizedTableFieldSelect>(args: FindFirstArgs<S, DenormalizedTableFieldFilter> & {
+    findFirst<S extends DenormalizedTableFieldSelect>(args: FindFirstArgs<S, DenormalizedTableFieldFilter, DenormalizedTableFieldOrderBy> & {
         select: S;
     } & StrictSelect<S, DenormalizedTableFieldSelect>): QueryBuilder<{
-        denormalizedTableFields: {
-            nodes: InferSelectResult<DenormalizedTableFieldWithRelations, S>[];
-        };
+        denormalizedTableField: InferSelectResult<DenormalizedTableFieldWithRelations, S> | null;
     }>;
     findOne<S extends DenormalizedTableFieldSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DenormalizedTableFieldModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DenormalizedTableField', 'denormalizedTableFields', args.select, {
             where: args?.where,
-        }, 'DenormalizedTableFieldFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DenormalizedTableFieldFilter', 'DenormalizedTableFieldOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DenormalizedTableField',
-            fieldName: 'denormalizedTableFields',
+            fieldName: 'denormalizedTableField',
             document,
             variables,
+            transform: (data) => ({
+                denormalizedTableField: data.denormalizedTableFields?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DevicesModuleModel {
     } & StrictSelect<S, DevicesModuleSelect>): QueryBuilder<{
         devicesModules: ConnectionResult<InferSelectResult<DevicesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends DevicesModuleSelect>(args: FindFirstArgs<S, DevicesModuleFilter> & {
+    findFirst<S extends DevicesModuleSelect>(args: FindFirstArgs<S, DevicesModuleFilter, DevicesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DevicesModuleSelect>): QueryBuilder<{
-        devicesModules: {
-            nodes: InferSelectResult<DevicesModuleWithRelations, S>[];
-        };
+        devicesModule: InferSelectResult<DevicesModuleWithRelations, S> | null;
     }>;
     findOne<S extends DevicesModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DevicesModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DevicesModule', 'devicesModules', args.select, {
             where: args?.where,
-        }, 'DevicesModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DevicesModuleFilter', 'DevicesModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DevicesModule',
-            fieldName: 'devicesModules',
+            fieldName: 'devicesModule',
             document,
             variables,
+            transform: (data) => ({
+                devicesModule: data.devicesModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {