DataSync Filesystem SDK API Reference

import { Contentstack } from "@contentstack/datasync-filesystem-sdk";
const config = {
  contentStore: {
    baseDir: './_contents',
    defaultSortingField: 'updated_at',
    locale: 'en-us',
    projections: {
      _content_type_uid: 0,
    },
    referenceDepth: 2,
  },
}

const Stack = Contentstack.Stack(config);

Stack
 .contentType('example')
 .entries()
 .and([{ title: 'John' }, { age: 30 } ])
 .find()
 .then((result) => {
   // Queries local filesystem for entries with title "John" and age 30
 })
 .catch((error) => {
   // Handle errors that occur during the query execution
 })

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.ascending('created_at').find()
data.then((result) => {
  // ‘result’ contains the list of entries which is sorted in ascending order on the basis of ‘created_at’.
}).catch((error) => {
  // Handle errors that occur during the query execution
})

Stack.asset('uid').find();
// or
Stack.asset().find();

Stack.assets().find();

Stack.connect({ overrides })
  .then((baseDir) => {
    // Connection established
  })
  .catch((error) => {
    // Handle errors related to filesystem connection
  });

Stack.contentType('example').find()
 .then((result) => {
   // returns entries filtered based on 'example' content type
 })
 .catch((error) => {
   // Handle errors that occur during the query execution
 })

Stack.contentTypes().find()

const query = Stack.contentType('example').entries().count().find()
query.then((result) => {
  // returns 'example' content type's entries
}).catch(error) => {
  // Handle errors that occur during the query execution
})

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.descending('created_at').find()
data.then((result) => {
  // ‘result’ contains the list of entries which is sorted in descending order on the basis of ‘created_at’.
}).catch((error) => {
  // Handle errors that occur during the query execution
})

Stack.contentType('example').entry('bltabcd12345').find();
// or
Stack.contentType('example').entry().find();

const query = Stack.contentType('example').entries().except(['title','uid']).find()
query.then((result) => {
  // ‘result’ contains a list of entries without field title and uid 
}).catch((error) => {
  // Handle errors that occur during the query execution
})

Stack.contentType('example')
 .entries()
 .excludeReferences()
 .find()
 .then((result) => {
   // ‘result’ entries without references
 }).catch((error) => {
   // Handle errors that occur during the query execution
 })

Stack.contentType('example').entries().find();

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.exists('featured').find()
data.then((result) => {
  // ‘result’ contains the list of entries in which "featured" exists.
}).catch((error) => {
  // Handle errors that occur during the query execution
})

Stack.contentType('blog')
 .entries()
 .findOne()

Stack.contentType('blog').entries().find()
.then((result) => {
   // returns blog content type's entries
})
.catch((error) => {
   // Handle errors that occur during the query execution
})

Stack.contentType('example')
 .equalTo('title','Demo')
 .getQuery()
 .find()

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.greaterThan('created_at','2015-03-12').find()
data.then((result) => {
  // result contains the data of entries where the 'created_at' date will be greaterthan '2015-03-12'
}).catch((error) => {
  // Handle errors that occur during the query execution
})

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.greaterThanOrEqualTo('created_at','2015-03-12').find()
data.then((result) => {
  // result contains the data of entries where the 'created_at' date will be  greaterThan or equalto '2015-03-12'
}).catch((error) => {
  // Handle errors that occur during the query execution
})

Stack.contentType('example')
 .entries()
 .include(['authors','categories'])
 .find()

Stack.contentType('example')
 .entries()
 .includeCount()
 .find()

Stack.contentType('example')
 .entries()
 .includeContentType()
 .find()
 .then((result) => {
   // Expected result
   {
     entries: [
       {
         ...,
       },
     ],
     content_type_uid: 'example',
     locale: 'en-us',
     content_type: {
       ..., // Content type example's schema
     }
   }
 }).catch((error) => {
   // Handle errors that occur during the query execution
 })

Stack.contentType('example')
 .entries()
 .includeReference()
 .find()

Stack.contentType('blog').entries().language('fr-fr').find();

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.lessThan('created_at','2015-06-22').find()
data.then((result) => {
  // result contains the data who's 'created_at date' is less than '2015-06-22'
}).catch((error) => {
  // Handle errors that occur during the query execution
})

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.lessThanOrEqualTo('created_at','2015-06-22').find()
data.then((result) => {
  // result contain the data of entries where the 'created_at' date will be less than or equalto '2015-06-22'.
}).catch((error) => {
  // Handle errors that occur during the query execution
})

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.limit(10).find()
data.then((result) => {
  // result contains the limited number of entries
}).catch((error) => {
  // Handle errors that occur during the query execution
})

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.notContainedIn('title', ['Demo', 'Welcome']).find()
data.then((result) => {
  // 'result' contains the list of entries where value of the title field should not be either "Demo" or ‘Welcome’
}).catch((error) => {
  // Handle errors that occur during the query execution
})

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.notEqualTo('title','Demo').find()
data.then((result) => {
  // ‘result’ contains the list of entries where value of the ‘title’ field will not be 'Demo'.
}).catch((error) => {
  // Handle errors that occur during the query execution
})

const query = Stack.contentType('example').entries().only(['title','uid']).find()
query.then((result) => {
  // ‘result’ contains a list of entries with field title and uid only
}).catch((error) => {
  // Handle errors that occur during the query execution
})

Stack
 .contentType('example')
 .entries()
 .or([{ title: 'John'}, { title: 'Jane'}])
 .find()
 .then((result) => {
   //  Queries local filesystem for entries with title "John" and age 30
 })
 .catch((error) => {
    // Handle errors that occur during the query execution
})

Stack.contentType('example').entries().query({"authors.name": "John Doe"}).find()
 .then((result) => {
   // returns entries, who's reference author's name equals "John Doe"
 })
 .catch((error) => {
   // Handle errors that occur during the query execution
 })

Stack.contentType('blog')
 .entries()
 .includeReference() // This would include all references of the content type
 .queryReferences({"authors.name": "John Doe"})
 .find()

Stack.contentType('blog')
 .entries()
 .includeReferences()
 .referenceDepth(4)
 .find()

let blogQuery = Stack.contentType('example').entries()
blogQuery.regex('title','^Demo').find() //regex without options
//or
blogQuery.regex('title','^Demo', 'i').find() //regex with options

Stack.schema(uid?: string).find()

Stack.schemas.find()

let blogQuery = Stack.contentType('example').entries()
let data = blogQuery.skip(5).find()
data.then((result) => {
  //result
}).catch((error) => {
  // Handle errors that occur during the query execution
})

const query = Stack.contentType('example').entries().tags(['technology', 'business']).find()
query.then((result) => {
  // "result" contains list of entries which have tags "technology" and "business".
}).catch((error) => {
  // Handle errors that occur during the query execution
})

const query = Stack.contentType('example').entries().where("this.title === 'Amazon_Echo_Black'").find()
query.then((result) => {
  // ‘result’ contains the list of entries where value of ‘title’ is equal to ‘Amazon_Echo_Black’.
}).catch(error) => {
  // Handle errors that occur during the query execution
})