@strapi/database 4.2.0-alpha.9 → 4.2.0-beta.1

package/lib/connection.js

@@ -0,0 +1,64 @@
+/* eslint-disable node/no-missing-require */
+/* eslint-disable node/no-extraneous-require */
+'use strict';
+
+const knex = require('knex');
+
+const SqliteClient = require('knex/lib/dialects/sqlite3/index');
+
+const trySqlitePackage = packageName => {
+  try {
+    require.resolve(packageName);
+    return packageName;
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      return false;
+    }
+    throw error;
+  }
+};
+class LegacySqliteClient extends SqliteClient {
+  _driver() {
+    return require('sqlite3');
+  }
+}
+
+const clientMap = {
+  'better-sqlite3': 'better-sqlite3',
+  '@vscode/sqlite3': 'sqlite',
+  sqlite3: LegacySqliteClient,
+};
+
+const getSqlitePackageName = () => {
+  // NOTE: allow forcing the package to use (mostly used for testing purposes)
+  if (typeof process.env.SQLITE_PKG !== 'undefined') {
+    return process.env.SQLITE_PKG;
+  }
+
+  // NOTE: this tries to find the best sqlite module possible to use
+  // while keeping retro compatibility
+  return (
+    trySqlitePackage('better-sqlite3') ||
+    trySqlitePackage('@vscode/sqlite3') ||
+    trySqlitePackage('sqlite3')
+  );
+};
+
+const createConnection = config => {
+  const knexConfig = { ...config };
+  if (knexConfig.client === 'sqlite') {
+    const sqlitePackageName = getSqlitePackageName();
+
+    knexConfig.client = clientMap[sqlitePackageName];
+  }
+
+  const knexInstance = knex(knexConfig);
+
+  return Object.assign(knexInstance, {
+    getSchemaName() {
+      return this.client.connectionSettings.schema;
+    },
+  });
+};
+
+module.exports = createConnection;

package/lib/dialects/mysql/schema-inspector.js

@@ -48,7 +48,7 @@ const toStrapiType = column => {
   switch (rootType) {
     case 'int': {
       if (column.column_key === 'PRI') {
-        return { type: 'increments', args: [{ primary: true }], unsigned: false };
+        return { type: 'increments', args: [{ primary: true, primaryKey: true }], unsigned: false };
       }
 
       return { type: 'integer' };

package/lib/dialects/sqlite/schema-inspector.js

@@ -16,7 +16,7 @@ const toStrapiType = column => {
   switch (rootType) {
     case 'integer': {
       if (column.pk) {
-        return { type: 'increments', args: [{ primary: true }] };
+        return { type: 'increments', args: [{ primary: true, primaryKey: true }] };
       }
 
       return { type: 'integer' };

package/lib/entity-manager.js

@@ -166,10 +166,12 @@ const createEntityManager = db => {
 
       const dataToInsert = processData(metadata, data, { withDefaults: true });
 
-      const [id] = await this.createQueryBuilder(uid)
+      const res = await this.createQueryBuilder(uid)
         .insert(dataToInsert)
         .execute();
 
+      const id = res[0].id || res[0];
+
       await this.attachRelations(uid, id, data);
 
       // TODO: in case there is no select or populate specified return the inserted data ?

package/lib/index.js

@@ -1,28 +1,17 @@
 'use strict';
 
-const knex = require('knex');
-
 const { getDialect } = require('./dialects');
 const createSchemaProvider = require('./schema');
 const createMetadata = require('./metadata');
 const { createEntityManager } = require('./entity-manager');
 const { createMigrationsProvider } = require('./migrations');
 const { createLifecyclesProvider } = require('./lifecycles');
+const createConnection = require('./connection');
 const errors = require('./errors');
 
 // TODO: move back into strapi
 const { transformContentTypes } = require('./utils/content-types');
 
-const createConnection = config => {
-  const knexInstance = knex(config);
-
-  return Object.assign(knexInstance, {
-    getSchemaName() {
-      return this.client.connectionSettings.schema;
-    },
-  });
-};
-
 class Database {
   constructor(config) {
     this.metadata = createMetadata(config.models);

package/lib/schema/schema.js

@@ -105,7 +105,7 @@ const getColumnType = attribute => {
     case 'increments': {
       return {
         type: 'increments',
-        args: [{ primary: true }],
+        args: [{ primary: true, primaryKey: true }],
         notNullable: true,
       };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.2.0-alpha.9",
+  "version": "4.2.0-beta.1",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -34,7 +34,7 @@
     "date-fns": "2.22.1",
     "debug": "4.3.1",
     "fs-extra": "10.0.0",
-    "knex": "0.95.6",
+    "knex": "1.0.4",
     "lodash": "4.17.21",
     "umzug": "2.3.0"
   },
@@ -42,5 +42,5 @@
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "db70f0de7cc73fb469c8a076b89530729cf14142"
+  "gitHead": "4fa2804f35e15ed72dfd309fb5bb1c4dba18932f"
 }

package/examples/connections.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const postgres = {
-  client: 'postgres',
-  connection: {
-    database: 'strapi',
-    user: 'strapi',
-    password: 'strapi',
-  },
-  // debug: true,
-};
-
-const mysql = {
-  client: 'mysql',
-  connection: {
-    database: 'strapi',
-    user: 'strapi',
-    password: 'strapi',
-  },
-  // debug: true,
-};
-
-const sqlite = {
-  client: 'sqlite',
-  connection: {
-    filename: 'data.sqlite',
-  },
-  useNullAsDefault: true,
-  // debug: true,
-};
-
-module.exports = {
-  sqlite,
-  postgres,
-  mysql,
-};

package/examples/docker-compose.yml

@@ -1,29 +0,0 @@
-version: '3'
-
-services:
-  postgres:
-    image: postgres
-    restart: always
-    volumes:
-      - ./data/postgresql:/var/lib/postgresql/data
-    environment:
-      POSTGRES_USER: strapi
-      POSTGRES_PASSWORD: strapi
-      POSTGRES_DB: strapi
-    ports:
-      - '5432:5432'
-
-  mysql:
-    image: mysql
-    restart: always
-    command: --default-authentication-plugin=mysql_native_password
-    environment:
-      MYSQL_DATABASE: strapi
-      MYSQL_USER: strapi
-      MYSQL_PASSWORD: strapi
-      MYSQL_ROOT_HOST: '%'
-      MYSQL_ROOT_PASSWORD: strapi
-    volumes:
-      - ./data/mysql:/var/lib/mysql
-    ports:
-      - '3306:3306'

package/examples/index.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const util = require('util');
-
-const { Database } = require('../lib/index');
-const models = require('./models');
-const connections = require('./connections');
-
-async function main(connection) {
-  const orm = await Database.init({
-    connection,
-    models: Database.transformContentTypes(models),
-  });
-
-  try {
-    // await orm.schema.drop();
-    // await orm.schema.create();
-
-    await orm.schema.reset();
-
-    let res;
-
-    const c1 = await orm.query('comment').create({
-      data: {
-        title: 'coucou',
-      },
-    });
-
-    const c2 = await orm.query('video-comment').create({
-      data: {
-        title: 'coucou',
-      },
-    });
-
-    res = await orm.query('article').create({
-      data: {
-        dz: [
-          {
-            __type: 'comment',
-            id: c1.id,
-          },
-          {
-            __type: 'video-comment',
-            id: c2.id,
-          },
-        ],
-      },
-      populate: {
-        dz: true,
-      },
-    });
-
-    log(res);
-
-    res = await orm.query('article').findMany({
-      populate: {
-        dz: true,
-      },
-    });
-
-    log(res);
-
-    // await tests(orm);
-  } finally {
-    orm.destroy();
-  }
-}
-
-function log(res) {
-  console.log(util.inspect(res, null, null, true));
-}
-
-main(connections.sqlite);

package/examples/models.js

@@ -1,341 +0,0 @@
-'use strict';
-
-const category = {
-  modelName: 'category',
-  uid: 'category',
-  collectionName: 'categories',
-  attributes: {
-    title: {
-      type: 'string',
-    },
-    price: {
-      type: 'integer',
-      required: true,
-      default: 12,
-
-      column: {
-        unique: true,
-        nonNullable: true,
-        unsigned: true,
-        defaultTo: 12,
-      },
-    },
-    articles: {
-      type: 'relation',
-      relation: 'oneToMany',
-      target: 'article',
-      mappedBy: 'category',
-    },
-    compo: {
-      type: 'component',
-      component: 'compo',
-    },
-  },
-};
-
-const article = {
-  modelName: 'article',
-  uid: 'article',
-  collectionName: 'articles',
-  attributes: {
-    title: {
-      type: 'string',
-    },
-    category: {
-      type: 'relation',
-      relation: 'manyToOne',
-      target: 'category',
-      inversedBy: 'articles',
-      // useJoinTable: false,
-    },
-    // tags: {
-    //   type: 'relation',
-    //   relation: 'manyToMany',
-    //   target: 'tag',
-    //   inversedBy: 'articles',
-    // },
-    // compo: {
-    //   type: 'component',
-    //   component: 'compo',
-    //   // repeatable: true,
-    // },
-    // cover: {
-    //   type: 'media',
-    //   single: true,
-    // },
-    // gallery: {
-    //   type: 'media',
-    //   multiple: true,
-    // },
-  },
-};
-
-const tags = {
-  modelName: 'tag',
-  uid: 'tag',
-  collectionName: 'tags',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    articles: {
-      type: 'relation',
-      relation: 'manyToMany',
-      target: 'article',
-      mappedBy: 'tag',
-    },
-  },
-};
-
-const compo = {
-  modelName: 'compo',
-  uid: 'compo',
-  collectionName: 'compos',
-  attributes: {
-    key: {
-      type: 'string',
-    },
-    value: {
-      type: 'string',
-    },
-  },
-};
-
-const user = {
-  modelName: 'user',
-  uid: 'user',
-  collectionName: 'users',
-  attributes: {
-    address: {
-      type: 'relation',
-      relation: 'oneToOne',
-      target: 'address',
-      inversedBy: 'user',
-      // useJoinTable: false,
-    },
-  },
-};
-
-const address = {
-  modelName: 'address',
-  uid: 'address',
-  collectionName: 'addresses',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    user: {
-      type: 'relation',
-      relation: 'oneToOne',
-      target: 'user',
-      mappedBy: 'address',
-    },
-  },
-};
-
-const file = {
-  modelName: 'file',
-  uid: 'file',
-  collectionName: 'files',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    alternativeText: {
-      type: 'string',
-    },
-    caption: {
-      type: 'string',
-    },
-    width: {
-      type: 'integer',
-    },
-    height: {
-      type: 'integer',
-    },
-    formats: {
-      type: 'json',
-    },
-    hash: {
-      type: 'string',
-    },
-    ext: {
-      type: 'string',
-    },
-    mime: {
-      type: 'string',
-    },
-    size: {
-      type: 'decimal',
-    },
-    url: {
-      type: 'string',
-    },
-    previewUrl: {
-      type: 'string',
-    },
-    provider: {
-      type: 'string',
-    },
-    provider_metadata: {
-      type: 'json',
-    },
-    // related: {
-    //   type: 'relation',
-    //   relation: 'oneToMany',
-    //   target: 'file_morph',
-    //   mappedBy: 'file',
-    // },
-    // related: {
-    //   type: 'relation',
-    //   realtion: 'morphTo',
-    // },
-  },
-};
-
-const fileMorph = {
-  modelName: 'file-morph',
-  uid: 'file-morph',
-  collectionName: 'file_morphs',
-  attributes: {
-    // file: {
-    //   type: 'relation',
-    //   relation: 'manyToOne',
-    //   target: 'file',
-    //   inversedBy: 'related',
-    //   useJoinTable: false,
-    // },
-  },
-};
-
-const blogPost = {
-  modelName: 'blogPost',
-  uid: 'blogPost',
-  collectionName: 'blog_posts',
-  attributes: {
-    passwordField: {
-      type: 'password',
-    },
-    emailField: {
-      type: 'email',
-    },
-    stringField: {
-      type: 'string',
-    },
-    uidField: {
-      type: 'uid',
-    },
-    richtextField: {
-      type: 'richtext',
-    },
-    textField: {
-      type: 'text',
-    },
-    enumerationField: {
-      type: 'enumeration',
-      enum: ['A', 'B'],
-    },
-    jsonField: {
-      type: 'json',
-    },
-    bigintegerField: {
-      type: 'biginteger',
-    },
-    integerField: {
-      type: 'integer',
-    },
-    floatField: {
-      type: 'float',
-    },
-    decimalField: {
-      type: 'decimal',
-    },
-    dateField: {
-      type: 'date',
-    },
-    timeField: {
-      type: 'time',
-    },
-    datetimeField: {
-      type: 'datetime',
-    },
-    timestampField: {
-      type: 'timestamp',
-    },
-    booleanField: {
-      type: 'boolean',
-    },
-  },
-};
-
-module.exports = [category, article, tags, compo, user, address, file, fileMorph, blogPost];
-
-// const article = {
-//   modelName: 'article',
-//   uid: 'article',
-//   collectionName: 'articles',
-//   attributes: {
-//     commentable: {
-//       type: 'relation',
-//       relation: 'morphToOne',
-//     },
-//     reportables: {
-//       type: 'relation',
-//       relation: 'morphToMany',
-//     },
-//     dz: {
-//       type: 'dynamiczone',
-//       components: ['comment', 'video-comment'],
-//     },
-//   },
-// };
-
-// const comment = {
-//   modelName: 'comment',
-//   uid: 'comment',
-//   collectionName: 'comments',
-//   attributes: {
-//     article: {
-//       type: 'relation',
-//       relation: 'morphOne',
-//       target: 'article',
-//       morphBy: 'commentable',
-//     },
-//     title: {
-//       type: 'string',
-//     },
-//   },
-// };
-
-// const videoComment = {
-//   modelName: 'video-comment',
-//   uid: 'video-comment',
-//   collectionName: 'video_comments',
-//   attributes: {
-//     articles: {
-//       type: 'relation',
-//       relation: 'morphMany',
-//       target: 'article',
-//       morphBy: 'commentable',
-//     },
-//     title: {
-//       type: 'string',
-//     },
-//   },
-// };
-
-// const folder = {
-//   modelName: 'folder',
-//   uid: 'folder',
-//   collectionName: 'folders',
-//   attributes: {
-//     articles: {
-//       type: 'relation',
-//       relation: 'morphMany',
-//       target: 'article',
-//       morphBy: 'reportables',
-//     },
-//   },
-// };
-
-// module.exports = [article, comment, videoComment, folder];

package/examples/typings.ts

@@ -1,17 +0,0 @@
-type ID = number | string;
-
-interface Category {
-  id: ID;
-  title: string;
-}
-
-interface Article {
-  id: ID;
-  title: string;
-  category: Category | ID;
-}
-
-interface AllTypes {
-  article: Article;
-  category: Category;
-}